Mureakuha

Teknisistä rajoituksista johtuen artikkelin yllä näkyvä otsikko on virheellinen. Oikea otsikko on C#-opas: Olioiden hienouksia.

Sisällysluettelo 1 ABSTRACT 2 VIRTUAL 3 static 4 SEALED 5 Tyyppimuunnokset 5.1 IS 5.2 AS 5.3 Type-tyyppi 5.4 Omien tyyppimuunnosten kirjoittaminen

ABSTRACT

Abstract-avainsanalla voidaan määrittää metodi tai luokka abstraktiksi. Tälläinen luokka on perittävä ja abstraktiksi määritetyt metodin on ylikirjoitettava. Luokka voi olla pelkästään abstrakti ilman metodeja, mutta jos yksikin metodi määritetään abstraktiksi on myös luokka määritettävä abstraktiksi.

Abstraktit metodit käyttäytyvät virtuaalisesti eli kantaluokaksi esitelty muuttuja kutsuu kuitenkin omanluokkansa metodeja. Edellyttää tietenkin sitä, että metodi, jota kutsutaan on abstrakti. Abstraktilla luokalla voi olla metodeja, jotka eivät ole abstrakteja ja niitä käsitellään kuten normaaleja periytettyjen luokkien metodeja.

Esimerkki:

using System;
 
public abstract class Shape
{
    //...Class implementation
 
    public abstract void Draw(int x, int y);
    //{
        //this method mustn't be implemented here.
        //If we do implement it, the result is a Syntax Error.
    //} 
}
 
 
 
public class Circle : Shape
{
	public Circle() { }
    //here we should provide an implemetation for Draw(int x, int y)
    public override void Draw(int x, int y)
    {
        //must do some work here
        Console.WriteLine("Piirretään {0} {1}",x,y);
    }
    
    public static void Main()
    {
    	Shape circle = new Circle();
    	circle.Draw(12,21);
    }
 
}

VIRTUAL

using System;
 
public class Shape
{
    //...Class implementation
 
    public virtual void Draw(int x, int y) 
    {
    	Console.WriteLine("Shape luokan Draw");
    } 
}
 
public class Boxi:Shape
{
	public void Draw(int x, int y)
	{
		Console.WriteLine("Boxi {0} {1}",x,y);
	}
}
 
public class Circle : Shape
{
	public Circle() { }
    //here we should provide an implemetation for Draw(int x, int y)
    public override void Draw(int x, int y)
    {
        //must do some work here
        Console.WriteLine("Ympyrä {0} {1}",x,y);
    }
    
    public static void Main()
    {
    	Shape circle = new Circle();
    	circle.Draw(12,21); //ylikirjoitettu ja kutsuu Circle
    	                    //luokan Draw metodia
 
        Shape boxi = new Boxi();
    	boxi.Draw(12,21); //ei ylikirjoitettu kutsuu Shape
    	                    //luokan Draw Metodia
    	                    
    }
 
}

static

C# 2.0 toi mukanaan static määreen luokalle. Tämä tarkoittaa sitä, että luokka voi sisältää vain staattisia jäseniä, mukaanlukien staattisen konstruktorin, ja että luokasta ei voi luoda instanssia. Aikaisemmin tämä on pitänyt toteuttaa määrittelemällä luokan konstruktori privaatiksi. Staattiset luokat ovat myös "sealed."

using System.Configuration;
 
public static class Settings
{
    public static string ConnectionString 
    { 
        get 
        { 
            return ConfigurationManager.AppSettings["ConnectionString"];
        }
    }
}

SEALED

Tälläisen metodin ylikirjoittaminen jälkeläisissä tuottaa virheilmoituksen käännettäessä. Sealed avainsana voi olla myös annettu luokalle, jolloin luokan periytyminen ei ole enää mahdollista.

public sealed override string ToString() { ... )

Tyyppimuunnokset

IS

IS operaattorilla voidaan testata onko muuttuja tiettyä tyyppiä tai toteuttaako se rajapinnan.

Object olio = Luokka(); //Luokka periytyy Object luokasta
if(olio is Luokka)
{
    //Tämä olio on Luokka luokan ilmentymä
    //Muunnetaan se
    Luokka l = (Luokka)olio;
}

AS

Viittausmuuttujan eksplisiittinen muunnos on mahdollista tehdä myös AS-operaattorilla. AS-operaattori tekee myös tarkistuksen lisäksi muunnoksen, jos muunnos ei ole mahdollinen palauttaa null.

Object olio = Luokka();
Luokka l = l as Luokka;
if(l != null)
{
    //Muunnos onnistui
} else {
    //Muunnos epäonnistui
}

Type-tyyppi

System.Type:llä voidaan ohjelmallisesti käsitellä tyyppi tietoutta. Type-objectin avulla voidaan kysyä tyypiltä nimeä, nimiavaruuttan jäseniä. Typellä voidaan käsitellä luokkia, arvotyyppejä, taulukoita, rajapintoja ja enummeja, mutta ei delegaatteja.

Typen ilmentymän luonti tavat

• olio.GetType(); //Metodi palauttaa type olion.
• typeof(TyypinNimi); //operaattori palautta kyseisen tyypin type-instanssin.
• Type.GetType("nimi"); //palauttaa annetun tekstin perusteella type-instanssin.
• Module.GetType,
• Module.GetTypes,
• Module.FindTypes //palauttavat moduulin tyypin kaikkineen jäseninen myös private. Moduuli tyyppi saadaan esim. Assembly.GetModule tai Assembly.GetModules tai Type.Module
• Type.GetInterface // kertoo rajapinnat
• Type.FindInterfaces //suodatuksen kanssa
• Type.GetElementType //elementti taulukko

Omien tyyppimuunnosten kirjoittaminen

Esimerkki luokka ei ole peritty int typpistä, mutta sille voidaan tehdä oma tyyppimuunnos operaattori näin.

public class Esimerkki
{
    private int oma;
    public static implicit operator Esimerkki(int joku)
    {
       return new Esimerkki(joku);
    }
    public Esimerkki(int oma)
    {
       this.oma = oma;
    }
    public static void Main()
    {
       Esimerkki e = 5;
       Esimerkki e2 = (Esimerkki)5;
    }
}

public class Esimerkki
{
    private int oma;
    public static explicit operator Esimerkki(Esim2 joku)
    {
       return new Esimerkki(5);
    }
    public Esimerkki(int oma)
    {
       this.oma = oma;
    }
    public static void Main()
    {
    	Esim2 e3 = new Esim2();
    	Esimerkki e = (Esimerkki)e3;
    }
}
 
public class Esim2
{
	public Esim2() {
		
	}
}