Overerving en interfaces in C#

Overerving: bouw voort op bestaande klassen

Met overerving (inheritance) kan een klasse alle eigenschappen en methoden overnemen van een andere klasse. De basisklasse (parent) biedt het fundament; de afgeleide klasse (child) voegt toe of overschrijft.

// Basisklasse
class CADObject
{
    public string Laag { get; set; } = "0";
    public string Kleur { get; set; } = "ByLayer";

    public virtual void Beschrijf()
    {
        Console.WriteLine($"CAD-object op laag '{Laag}'");
    }
}

// Afgeleide klasse
class Cirkel : CADObject
{
    public double Straal { get; set; }

    public override void Beschrijf()
    {
        Console.WriteLine($"Cirkel (r={Straal}) op laag '{Laag}'");
    }
}

class Lijn : CADObject
{
    public double Lengte { get; set; }

    public override void Beschrijf()
    {
        Console.WriteLine($"Lijn ({Lengte} mm) op laag '{Laag}'");
    }
}

Polymorfisme: één type, veel gedragingen

Dankzij overerving kun je objecten van verschillende subklassen behandelen als de basisklasse:

List<CADObject> objecten = new List<CADObject>
{
    new Cirkel { Straal = 5.0, Laag = "Muren" },
    new Lijn   { Lengte = 200, Laag = "Maatvoering" },
    new Cirkel { Straal = 2.5, Laag = "Hulplijnen" },
};

foreach (CADObject obj in objecten)
{
    obj.Beschrijf();  // roept de juiste override aan!
}

abstract: verplicht overschrijven

Een abstract methode heeft geen implementatie in de basisklasse — elke subklasse moet haar zelf invullen:

abstract class Vorm
{
    public abstract double BerekenOppervlakte();
    public abstract double BerekenOmtrek();

    public void ToonResultaten()
    {
        Console.WriteLine($"Oppervlakte: {BerekenOppervlakte():F2}");
        Console.WriteLine($"Omtrek:      {BerekenOmtrek():F2}");
    }
}

class Rechthoek : Vorm
{
    public double Breedte { get; set; }
    public double Hoogte  { get; set; }

    public override double BerekenOppervlakte() => Breedte * Hoogte;
    public override double BerekenOmtrek()      => 2 * (Breedte + Hoogte);
}

Interfaces: afspraken zonder implementatie

Een interface is een lijst van methode-handtekeningen. Klassen die de interface implementeren beloven die methoden te voorzien:

interface IExporteerbaar
{
    void ExporteerNaarPDF(string pad);
    void ExporteerNaarDXF(string pad);
}

interface IPrintbaar
{
    void Print(string printer);
}

class Tekening : IExporteerbaar, IPrintbaar
{
    public string Naam { get; set; } = "";

    public void ExporteerNaarPDF(string pad)
        => Console.WriteLine($"{Naam} geëxporteerd naar {pad}.pdf");

    public void ExporteerNaarDXF(string pad)
        => Console.WriteLine($"{Naam} geëxporteerd naar {pad}.dxf");

    public void Print(string printer)
        => Console.WriteLine($"{Naam} verzonden naar {printer}");
}

Interface vs abstract klasse

In de volgende post leren we hoe we fouten netjes afhandelen met try/catch.

Inheritance: build on existing classes

class CADObject
{
    public string Layer { get; set; } = "0";
    public string Color { get; set; } = "ByLayer";

    public virtual void Describe()
        => Console.WriteLine($"CAD object on layer '{Layer}'");
}

class Circle : CADObject
{
    public double Radius { get; set; }
    public override void Describe()
        => Console.WriteLine($"Circle (r={Radius}) on layer '{Layer}'");
}

class Line : CADObject
{
    public double Length { get; set; }
    public override void Describe()
        => Console.WriteLine($"Line ({Length} mm) on layer '{Layer}'");
}

Polymorphism

List<CADObject> objects = new List<CADObject>
{
    new Circle { Radius = 5.0, Layer = "Walls" },
    new Line   { Length = 200, Layer = "Dimensions" },
};

foreach (CADObject obj in objects)
    obj.Describe();  // calls the correct override!

abstract: force overriding

abstract class Shape
{
    public abstract double CalculateArea();
    public abstract double CalculatePerimeter();
}

class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }
    public override double CalculateArea() => Width * Height;
    public override double CalculatePerimeter() => 2 * (Width + Height);
}

Interfaces: contracts without implementation

interface IExportable
{
    void ExportToPDF(string path);
    void ExportToDXF(string path);
}

class Drawing : IExportable
{
    public string Name { get; set; } = "";
    public void ExportToPDF(string path)
        => Console.WriteLine($"{Name} exported to {path}.pdf");
    public void ExportToDXF(string path)
        => Console.WriteLine($"{Name} exported to {path}.dxf");
}

In the next post we learn how to handle errors cleanly with try/catch.