Erstes Beispielprojekt zu Events

Wir erstellen eine Klasse Rechner, diese besitz eine Methode Namens Addiere. Diese Methode soll 2 Zahlen miteinander addieren und das Ergebnis über einem Event veröffentlichen.

class Rechner {
    // Delegat welches vom Event verwendet wird um den Erfolg einer Rechnung zu Signalisieren    
    public delegate void ErgebnisRechnungsErfolgHandler(int ergebnis);
    // Event 
    public event ErgebnisRechnungsErfolgHandler ErgebnisMelden;
    /// <summary>
    /// Addieren 
    /// </summary>
    /// <param name="a">Zahl 1</param>
    /// <param name="b">Zahl 2</param>
    /// <remarks>
    /// Statt einen Rückgabewert wird ein Event ausgelößt wenn die Berechnung beendet ist
    /// </remarks>
    public void Addiere(int a, int b)
    {
        int result = a + b;

        // Event auslösen (kurze schreibweise)
        ErgebnisMelden?.Invoke(result);
        // Event auslösen (lange schreibweise)
        //if (!(ErgebnisMelden == null))
        //    ErgebnisMelden(result);
    }
}

Was geschieht in der Klasse Rechner:
Zunächst wird ein Delegate deklariert: „public delegate void ErgebnisRechnungsErfolgHandler(int ergebnis);„. Um die Grundlagen von Delegates zu vertiefen, kann dies an im Beitrag Delegates (Grundlagen) nachgelesen werden.
Anschließend wird das Delegate mit einem Event verbunden, das von der Klasse aufgerufen wird: „public event ErgebnisRechnungsErfolgHandler ErgebnisMelden;„. Das Schlüsselwort event stellt sicher, dass sich externe Teilnehmer nur an diesem Delegate anmelden (+=) oder abmelden (-=) können, während die Kontrolle bei der Klasse Rechner als Auslöser bleibt.
Um das Event auszulösen kann einfach das Event, wie auch jede andere Methode aufgerufen werden mit „ErgebnisMelden(result)“.
Aber ACHTUNG, wenn das Event nicht implementiert worden ist, tritt hier ein Fehler auf da der „Zeiger“ des Events ins nichts zeigt. Aus diesem Grund habe ich hier im Code 2 Möglichkeiten aufgezeigt welche ein Absturz des Programmes verhindern.
Die erste Möglichkeit und kurze Möglichkeit ist „ErgebnisMelden?.Invoke(result);“. Wenn das Event Ereignismelden abonniert ist, dann wird das Event ausgeführt, sollte es nicht abonniert sein, wird das Event nicht ausgelöst.
Die zweite Möglichkeit ist für Beginner mit der Thematik einfacher verständlich.

if (!(ErgebnisMelden == null))
    ErgebnisMelden(result);

Es wird erst geprüft ob das Event ErgebnisMelden abonniert ist. Wenn es abonniert ist, wird es ausgeführt.

Wir haben nun die Klasse die Arbeitet, nun möchten wir natürlich auch das Programm erstellen welches die Methoden der Klasse anwendet.

static void Main(string[] args){
    Rechner rechne = new Rechner();                 // Rechner instanziieren
    rechne.ErgebnisMelden += Rechne_ErgebnisMelden; // Event abonnieren
    rechne.Addiere(1, 2);
    Console.WriteLine("Taste zum beenden.");
    Console.ReadKey();
}
private static void Rechne_ErgebnisMelden(int ergebnis){
    Console.WriteLine($"Ergebnis der Berechnung: {ergebnis}");
}

Was geschieht im Code?
Nach der Instanziierung der Klasse wird das in der Klasse definierte Event ErgebnisMelden mittels += abonniert: „rech.ErgebnisMelden += Rechne_ErgebnisMelden;„. Das abonnierte Event verweist anschließend auf die Methode, die mit dem Ergebnis weiterarbeitet.

Dieses kleine Beispiel zeigt wie Events funktionieren.
Im Beispielcode Download zu diesem Artikel ist ein 2tes (Windows Forms Projekt) enthalten. In diesem Windows Forms Projekt ist eine Klasse welche eine längere Aufgabe (Strings addieren) übernimmt und mittels Event zum einen den Status der Aufgabe (z.B. für einen Fortschrittsbalken) übergibt und das Ende der Aktion signalisiert. Als lange Aufgabe habe ich das Beispiel aus dem Eintrag Coding: Vergleich Strings und Array mit viel Inhalt verwendet.

Warum Events verwenden? Ich habe mal ein Modul erstellt, welches eine Kasse mit einem Bezahlterminal kommuniziert (Kartenzahlung), Während der Kartenzahlung werden diverse Informationen zwischen Kasse und Terminal hin und her gesandt (besonders dann wenn nicht das EC Terminal, sondern die Kasse den Zahlungsbeleg druckt). Damit die Kasse sämtliche Informationen am Kunden und Kassiererdisplay/Monitor anzeigt oder Zahlungsstatis, Start/Ende des Zahlungvorganges, etc. habe ich hier Events verwendet.

Quellcode des Beispiel zum Download.

Der Beitrag Event (Grundlagen) erschien zuerst auf Gernardt.net.

Ein Delegate ist ein Datentyp, der eine Referenz auf Methoden speichern kann, wodurch Methoden wie Parameter behandelt werden können. Dies ermöglicht es, Methoden als Parameter an andere Methoden zu übergeben oder sie in Ereignstrukturen einzusetzen.

Kleines Beispiel der Verwendung eines einfachen Delegates

public delegate int Berechnung(int a, int b);   
// - Definition: Ein Delegate wird ähnlich einer Methode deklariert, lediglich ohne Rumpf

static void Main(string[] args){
    Berechnung addiere = (a, b) => a + b;
    Console.WriteLine("Ergebnis Addition: " + addiere(2, 2));

    Berechnung multipliziere = (c, d) => c * d;
    Console.WriteLine("Ergebnis Multiplikation: " + multipliziere (2, 2));

    Berechnung dividiere = (e, f) => e / f;
    Console.WriteLine("Ergebnis Dividition: " + dividiere(2, 2));

    Berechnung subtrahiere = (g, h) => g - h;
    Console.WriteLine("Ergebnis Subtration: " + subtrahiere(2, 2));
    Console.WriteLine("");
    Console.WriteLine("Zum Beenden Taste drücken");
    var nix = Console.ReadKey();
}

Was macht der obere Code?

Zuerst wird das Delegate mit der Deklaration „public delegate int Berechnung(int a int b);“ definiert. Das Delegate besitzt keinen Rumpfkörper, sondern lediglich die Parameter, die benötigt werden.
Interessant wird es bei der Zeile „Berechnung addiere = (a, b) => a + b;„:
Es wird eine Variable (addiere) des Delegatentyps Berechnung erstellt. Mit dem Lambda-Ausdruck ((a, b) => a + b) wird festgelegt, was mit den Variablen geschehen soll. In diesem kleinen Beispielprojekt wurde die kompakte Schreibweise gewählt. Lambda-Ausdrücke werden uns im Laufe der Zeit immer wieder begegnen. Innerhalb von Lambda-Ausdrücken können unter anderem auch ganze Methoden definiert werden. Dazu jedoch später mehr. Die Variable addiere ist nun eine Variable, die die Methode speichert. Wird also addiere mit den Parametern aufgerufen, wie in diesem Beispiel addiere(2, 2), werden die beiden Zahlen entsprechend dem Lambda-Ausdruck addiert.

In dem oben gegebenen Code verwende ich 1 Delegate um Berechnungsoperationen durchzuführen und schreibe per Lambda Funktion die genauen Rechenoperationen (Beispiele => a+b, =>c*d, etc.).

Multicast Delegates

Bei Multicast-Delegates können Delegates Methoden abonnieren, die nacheinander aufgerufen werden.

Für dieses Beispiel erstellen wir einfache Rechenoperationen (wie im Code 1) als Funktionen:

static int MCastAddiere(int a, int b) {
    Console.WriteLine($"Addiere: {a + b}");
    return a + b;
}
static int MCastSubtrahiere(int a, int b){
    Console.WriteLine($"Subtrahiere: {a - b}");
    return a - b;
}
static int MCastMultipliziere(int a, int b){
    Console.WriteLine($"Multipliziere: {a * b}");
    return a - b;
}
static int MCastDividiere(int a, int b){
    Console.WriteLine($"Dividiere: {a / b}");
    return a - b;
}

Um in den Beispielcode zu unterscheiden, habe ich an den Funktionen das Präfix „MCast“ verwendet.

Als nächsten wird ein Delegate erstellt, mit den Parametern, welche für die Berechnungen verwendet werden;

public delegate int Rechne(int a, int b);

Nun werden wir das Delegat vom Typ Rechne erstellen und alle Funktionen, welche wir ausführen möchten an das Delegat vom Typ Rechne hängen:

Rechne rechner = mCastAddiere;
rechner += mCastSubtrahiere;
rechner += mCastMultipliziere;
rechner += mCastDividiere;

Mit „+=“ werden Methoden hinzugefügt und mit „-=“ werden Methoden wieder entfernt.

Und nun Ausführen aller 4 Funktionen das Delegat ausführen:

int ergebnis = rechner(2, 2); // Ausführen aller Funktionen mittels Delegate
Console.WriteLine($"Letztes Ergebnis: {ergebnis}");
Console.WriteLine("Zum Beenden Taste drücken.");
Console.ReadKey();

Wie wir hier sehen, können Multicast-Delegates ein äußerst nützliches Werkzeug sein, um insbesondere wiederholende Aufgaben zu erleichtern. Wenn wir jedoch die Zeile „Console.WriteLine($“Letztes Ergebnis: {ergebnis}“);“ genauer betrachten, stellen wir fest, dass nur das letzte Ergebnis zurückgegeben wird. Daher sollten Multicast-Delegates vor allem bei Methoden mit void-Rückgabewerten verwendet werden, da der aufrufende Code lediglich den Wert der letzten Funktion erhält.

Multicast Delegaten mit Rückgabenwerten

Das ist etwas knifflig. Im ersten Multi Delegate-Beispiel sehen wir, dass Ergebnisse mit Ausnahme des letzten Ergebnisses verloren gehen. Dies ist in der Praxis nicht immer zielführend. Um später mit „allen“ Ergebnissen arbeiten zu können, müssen wir etwas Gehirnschmalz einsetzen.

public delegate int Berechnung(int a, int b);

static void Main(string[] args
    int addiere(int a, int b) => a + b;
    int multipliziere(int a, int b) => a * b;
    int dividiere(int a, int b) => a / b;
    int subtrahiere(int a, int b) => a - b;

    Berechnung rechne = addiere;
    rechne += multipliziere;
    rechne += dividiere;
    rechne += subtrahiere;
        
    int[] ergebnisse = rechne 
        .GetInvocationList()
        .Select(d => ((Berechnung)d)(6, 2))
        .ToArray();

    foreach(int ergebnis in ergebnisse)
        Console.WriteLine ($"Ergebnis: {ergebnis}");
    Console.WriteLine("Zum beenden Taste drücken.");
    ConsoleKeyInfo nix = Console.ReadKey();
}

Neu ist hier das Array vom Typ int:

int[] ergebnisse = rechne 
    .GetInvocationList()
    .Select(d => ((Berechnung)d)(6, 2))
    .ToArray();

GetInvocationList() gibt ein Array aller im Delegate enthaltenen Methoden zurück.
Mit Select(…) rufen wir gezielt jede Funktion auf, die im Delegate referenziert wird, und erhalten das Ergebnis.
Das Array „ergebnisse“ enthält nun alle Rückgabewerte, auf die wir nach Belieben zugreifen und diese entsprechend verwenden können.

So verlieren wir keinen Rückgabewert mehr.

Hier in diesen Beispielen werden nur Funktionen verwendet die Rechnen, natürlich ist es Möglich mehrere Funktionen zu verwenden, die auch unterschiedliche Dinge mit den Parametern machen.

Alle aufgeführten Listenings sind im Beispielprojekt enthalten.

Download zu Grundlagen Delegaten

Der Beitrag Delegates (Grundlagen) erschien zuerst auf Gernardt.net.

• Abstrakte Klassen lassen sich nicht direkt instanziieren.
• Abstrakte Klassen können sowohl abstrakte als auch nicht-abstrakte Methoden, Funktionen und Attribute umfassen.
• Ermöglicht die Wiederverwendung von Quellcode.
• Dient als Basis für abgeleitete Klassen.
• Abstrakte Klassen dienen dazu, die Implementierung spezifischer Methoden, Funktionen und Attribute in abgeleiteten Klassen verbindlich vorzuschreiben.
• Abstrakte Klassen ermöglichen eine klare Struktur im Code, indem sie die direkte Instanziierung verhindern.
• Methoden, Funktionen und Attribute der abstrakten Klasse werden in den abgeleiteten Klassen gemeinsam genutzt, was die Wartbarkeit und Struktur des Codes erheblich vereinfacht.

Im ersten Teil der Grundlagen Verebung haben wir ein Beispielprojekt erstellt, das als abstrakte Klasse die Attribute, Methoden und Funktionen eines Fahrzeugs bereitstellt. Abgeleitete (Childs) sind „Auto“, „Motorrad“ und „LKW“. In diesem Beispielprojekt wird kurz erläutert, wie Methoden, Funktionen oder Attribute überladen werden können, wie etwa im Beispiel des Motorrads, das nicht rück fahren kann und bei dem die Methode „FahrenRueckwaerts“ überladen wurde. Sowie die Möglichkeit, je nach Fahrzeugtyp zusätzliche Methoden, Funktionen und Attribute hinzuzufügen (zum Beispiel bei einem LKW Kippen der Fahrerkabine).
Wer aufrichtig liest wird am Punkt 2 hängen geblieben sein „Abstrakte Klassen können sowohl abstrakte als auch nicht-abstrakte Methoden, Funktionen und Attribute umfassen“. Im Beispielcode sind in der Abstrakten Klasse „Fahrzeug“ nur nicht-abstrakte Methoden und Attribute verwendet worden. Was sind abstrakte Methoden?

Abstrakte Methoden (auch Funktionen und Attribute)

• Abstrakte Methoden werden nicht in der Basisklasse implementiert, nur die Methodensignatur ist vorhanden.
• Abstrakte Methoden müssen mittels Schlüsselwort override in der abgeleiteten Klasse (Child) überschrieben werden.
• Abstrakte Methoden können nur in abstrakte Klassen enthalten sein.
• Abstrakte Methoden müssen in der abgeleiteten Klasse (Child) implementiert werden.

In diesem Teil der Vererbung, werden wir die Klasse Fahrzeug um eine Funktion erweitern. Tanken! Jedes Fahrzeug benötigt Energie, egal ob Wasserstoff, Benzin/Diesel, oder geladen werden muss. Jeder dieser Vorgänge dauert seine Zeit und wird etwas anders ausgeführt und ist nicht bei jedem Fahrzeug gleich. Daher verwende ich mal die Funktion Tanken als Beispiel für abstrakte Funktionen.
Zuerst wird in der Abstrakte Klasse die Methoden Signatur festgelegt:

/// <summary>
/// Tanken
/// </summary>
/// <returns>Bei Erfolg true</returns>
/// <remarks>
/// Fahrzeuge müssen Tanken.
/// Ob Fossil oder regenerative Stoffe, ob Aufladen oder Wasserstoff, etc.
/// Bei abstrakten Methoden, Funktionen oder Attributen wird kein Code hinterlegt, lediglich die Signatur
/// </remarks>
public abstract bool Tanken();

Ab sofort ist es obligatorisch, die Funktion Tanken in allen abgeleiteten Klassen zu implementieren. Dadurch kann ich als Programmierer sicherstellen, dass bei neuen Fahrzeugen der oder die nächste Mitarbeiter:in die Funktion Tanken korrekt in neues Fahrzeug integriert.
Änderungen in den aktuellen abgeleiteten Klassen (als Beispiel nur die Änderung in der Klasse Auto) :

/// <summary>
/// Auto tanken
/// </summary>
/// <returns>Bei Erfolg true</returns>
public override bool Tanken()
{
    Console.WriteLine("Auto links neben der Tanksäule parken.");
    Console.WriteLine("Fahrer steigt aus.");
    Console.WriteLine("Fahrer öffnet Tankdeckel.");
    Console.WriteLine("Wagen wird mit Benzin getankt");
    Console.WriteLine("Fahrer schließt Tankdeckel.");
    Console.WriteLine("Fahrer bezahlt.");
    return true;
}

Eine Funktion Tanken muss nun in jeder abgeleiteten Klasse von „Fahrzeug“ implementiert werden.
Download bearbeiteter Code (Visual Studio).

Der Vorteil abstrakter Methoden besteht darin, dass sie eine klare Architektur erzwingen, während die einzelnen abgeleiteten Objekte die Methode entsprechend ihren Bedürfnissen implementieren können. Da die Methoden und Funktionen an die Anforderungen der Objekte angepasst sind, erfolgt auch die Wartung der Methoden und Funktionen innerhalb der abgeleiteten Klassen.

Der Beitrag Grundlagen Vererbung: Abstrakte Klassen erschien zuerst auf Gernardt.net.

• Wartbarkeit: Es müssen nur an einer Stelle Änderungen vorgenommen werden.
• Strukturiert: Der Code bleibt übersichtlich und leicht verständlich.
• Weniger Fehleranfälligkeit: Code-Duplikate erhöhen das Risiko inkonsistente Änderungen.

Beispiel Non DRY Code (schlecht umgesetzt)

Beispiel einer einfachen Steuerberechnung mit einem festen Steuersatz von 19 %, ohne Berücksichtigung weiterer Steuerstufen (wie 7 %, 0 % oder 10,7 % ab 2025 liegt der Steuersatz für land- und forstwirtschaftliche Betriebe gemäß der Durchschnittsbesteuerung nach § 24 UStG bei 7,8 %, da er schrittweise gesenkt wurde).

public class Rechnung {
        /// <summary>
        /// Volle USt aus dem Nettobetrag berechnen
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>USt Betrag</returns>
        public double BerechneSteuer(double Betrag) {
            return Betrag * 0.19;
        }
        /// <summary>
        /// Bruttobetrag der Rechnung
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>Bruttobetrag</returns>
        public double Bruttobetrag(double Betrag) {
            return Betrag * BerechneSteuer(84.03);
        }
    }

    public class Bon
    {
        /// <summary>
        /// Volle USt aus dem Nettobetrag berechnen
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>USt Betrag</returns>
        public double BerechneSteuer(double Betrag)
        {
            return Betrag * 0.19;
        }
        /// <summary>
        /// Bruttobetrag des Bons
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>Bruttobetrag</returns>
        public double Bruttobetrag(double Betrag)
        {
            return Betrag * BerechneSteuer(84.03);
        }
    }
    public class Einkauf
    {
        /// <summary>
        /// Volle USt aus dem Nettobetrag berechnen
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>USt Betrag</returns>
        public double BerechneSteuer(double Betrag)
        {
            return Betrag * 0.19;
        }
        /// <summary>
        /// Bruttobetrag des Einkaufs
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>Bruttobetrag</returns>
        public double Bruttobetrag(double Betrag)
        {
            return Betrag * BerechneSteuer(84.03);
        }
    }

Beispiel DRY Prinzip

    public class Berechnungen
    {
        /// <summary>
        /// Volle USt aus dem Nettobetrag berechnen
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>USt Betrag</returns>
        public static double BerechneSteuer(double Betrag)
        {
            return Betrag * (double)0.19;
        }
    }
    public class Rechnung
    {
        /// <summary>
        /// Bruttobetrag der Rechnung
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>Bruttobetrag</returns>
        public double Bruttobetrag(double Betrag)
        {
            return Betrag * Berechnungen.BerechneSteuer(84.03);
        }
    }

    public class Bon
    {
        /// <summary>
        /// Bruttobetrag des Bons
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>Bruttobetrag</returns>
        public double Bruttobetrag(double Betrag)
        {
            return Betrag * Berechnungen.BerechneSteuer(84.03);
        }
    }
    public class Einkauf
    {
        /// <summary>
        /// Bruttobetrag des Einkaufs
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>Bruttobetrag</returns>
        public double Bruttobetrag(double Betrag)
        {
            return Betrag * Berechnungen.BerechneSteuer(84.03);
        }
    }

Unterschiede zwischen beiden Listenings

Non DRY Code:
Im Non-DRY-Ansatz wird der reguläre Steuerbetrag (19 %) sowohl in den Klassen für Rechnungen, Einkauf und Bons separat berechnet. Ändert sich der Steuersatz, muss die Anpassung an mehreren Stellen vorgenommen werden – für Rechnung, Einkauf und Bon. Falls zusätzlich eine Angebotsberechnung hinzugefügt wird, müsste die Steuerlogik ein weiteres Mal programmiert oder kopiert werden, was die Wartung erschwert.

DRY Code:
Im DRY-Code wird die Berechnungsfunktion zentral definiert. Diese Funktion wird in den Klassen Einkauf, Rechnung und Bon verwendet. Ändert sich der Steuersatz, muss die Funktion nur an einer Stelle angepasst werden, wodurch der Code wartungsfreundlicher bleibt.

Info:
Im Normalfall werden Steuersätze nicht fest im Code hinterlegt, da sie sich mit der Zeit ändern und für verschiedene Artikel unterschiedlich gelten können. Ein Beispiel dafür ist die Besteuerung in einem Schnellrestaurant: Speisen, die im Restaurant verzehrt werden, unterliegen dem regulären Steuersatz von 19 %, während außer Haus verkaufte Speisen mit dem ermäßigten Steuersatz von 7 % besteuert werden.

Der Beitrag DRY Prinzip (Don’t Repeat Yourself) erschien zuerst auf Gernardt.net.

Grundlagen der Vererbung in C#

• Basisklasse (Parent): Die ursprüngliche Klasse, von der andere Klassen erben.
• Abgeleitete Klasse (Child): Die Klasse, welche die Eigenschaften und Methoden der Basisklasse übernimmt und erweitern kann.

Fallbeispiel

Ein ganz einfaches Beispiel, welches oft verwendet wird ist immer das Fahrzeuge. Dieses Beispiel verwende ich hier da zum einen nahezu jedem Fahrzeuge bekannt sind und zum anderen um spätere Beispielcodes aufbauend auf diesem Code zu verwenden.

Überlegung

Wir benötigen ein Auto, ein Motorrad und ein LKW. Alle drei Arten von Fahrzeuge haben gemeinsame Eigenschaften und Methoden, welche alle drei Fahrzeuge verwenden. Allerdings haben auch alle 3 Fahrzeugtypen unterschiedliche Methoden. Beispiel viele Motorräder können nicht rückwärts Fahren oder ein LKW kann die Fahrerkabine zur Reparatur herunterfahren. Ich selber bin kein Fahrzeugexperte, aber ich kann den Unterschied zwischen Adaptiv- und Leichtgewichtrollstuhl erklären :).
Beispiel einer (kleinen) Basisklasse:

public abstract class Fahrzeug{
        /// <summary>
        /// Farbe des Fahrzeug
        /// </summary>
        /// <remarks>
        /// Standardfarbe = Schwarz
        /// </remarks>
        public System.Drawing.Color FahrzeugFarbe { get; set; } = System.Drawing.Color.Black;
        /// <summary>
        /// Fahrzeug fährt vorwärts
        /// </summary>
        public void FahrenVorwaerts() {
            Console.WriteLine("Das Fahrzeug fährt.");
        }
        /// <summary>
        /// Fahrzeug Hupt
        /// </summary>
        public void Hupen() {
            Console.WriteLine("Das Fahrzeug hupt.");
        }

        /// <summary>
        /// Fahrzeug fährt rückwärts
        /// </summary>
        /// <remarks>
        /// Besonderheit: nicht jedes Fahrzeug kann rückwärts fahren!
        /// </remarks>
        public virtual void FahrenRueckwaerts(){
            Console.WriteLine("Das Fahrzeug fährt.");
        }
    }

Die oben gezeigte Basisklasse „Fahrzeug“ besitzt das Attribut Farbe, welches als Standard Schwarz ist, dazu die Methoden FahrenVorwaerts, FahrenRückwaerts sowie Hupen.
Dabei ist zu beachten das nicht jedes Fahrzeug rückwärts Fahren kann, daher habe ich in diesem Beispiel eine Methodenüberschreibung (override) erlaubt, was mit dem Schlüsselwort „virtual“ erlaubt wird.

Um ein Überschreiben von Methoden, Funktionen oder Eigenschaften (Attribute) zu erlauben, muss in der Basisklasse Basis- methode/-funktion/-Eigenschaft „virtual“ sein. Diese kann dann in der Kindklasse mit „override“ überschrieben werden.

Kindklassen

    /// <summary>
    /// Auto Klasse
    /// </summary>
    /// <remarks>Erbt von Fahrzeug</remarks>
    public class Auto : Fahrzeug {
        /// <summary>
        /// Konstrukt für Auto
        /// </summary>
        /// <param name="farbe">Farbe</param>
        public Auto(System.Drawing.Color farbe)
        {
            base.FahrzeugFarbe = farbe;
            base.ReifenAnzahl = 4;
            base.PS = 180;
        }
    }

    /// <summary>
    /// Motorrad Klasse
    /// </summary>
    /// <remarks>Erbt von Fahrzeug</remarks>
    public class Motorrad : Fahrzeug
    {
        /// <summary>
        /// Konstrukt für Motorrad
        /// </summary>
        /// <param name="farbe">Farbe</param>
        public Motorrad (System.Drawing.Color farbe)
        {
            base.FahrzeugFarbe = farbe;
            base.ReifenAnzahl = 2;
            base.PS = 35;
        }
        public override void FahrenRueckwaerts()
        {
            Console.WriteLine("Kindklasse: Das Motorrad hat keinen Rückwärtsgang!");
        }

    }

    /// <summary>
    /// LKW Klasse
    /// </summary>
    /// <remarks>Erbt von Fahrzeug</remarks>
    public class LKW : Fahrzeug
    {
        /// <summary>
        /// Konstrukt für LKW
        /// </summary>
        /// <param name="farbe">Farbe</param>
        public LKW(System.Drawing.Color farbe)
        {
            base.FahrzeugFarbe = farbe;
            base.ReifenAnzahl = 6;
            base.PS = 476;
        }
        /// <summary>
        /// Fahrerhaus kippen
        /// </summary>
        /// <remarks>
        /// diese Funktion besitzen nur LKWs</remarks>
        public void FahrerhausKippen() {
            Console.WriteLine("Kindklasse: Das Fahrerhaus wird gekippt!");
        }
    }

Da der Code der abgeleiteten Klassen (im Code Kindklasse oder auch Child genannt) nicht viel passiert, habe ich 1 Listening des Beispielcodes aller abgeleiteter Klassen verwendet.

Die abgeleiteten Klassen ändern sich nur gering.
Die Klasse „Auto“ besitzt sämtliche Attribute und Methoden der Basisklasse.
Die Klasse „Motorrad“ überschreibt die Methode „FahrenRueckwaerts“ da das erdachte Motorrad kein Rückwärtsgang hat. In der Konsole erscheint die Meldung „Kindklasse: Das Motorrad hat keinen Rückwärtsgang“.
Die Klasse „LKW“ hat eine weitere Methode, welche das Kippen des Fahrerhaus ermöglicht.

Wichtige Aspekte bei der Vererbung

• Basisklassenaufruf
  • Das base-Schlüsselwort auf Konstruktoren, Methoden, Funktionen oder Attribute der Basisklasse.
• Methodenüberschreibungen
  • Ermöglicht es, das geerbte Methoden, Funktionen oder Attribute innerhalb der Abgeleiteten(Child) Klasse zu verändern.
  • Um eine Methode, Funktion oder ein Attribute zu überschreiben muss diese Methode, Funktion oder das Attribute virtual sein.
    Virtuelle Methode, Funktion oder ein Attribute können mit override überschrieben werden (Beispiel in der abgeleiteten Klasse Motorrad public override void FahrenRueckwaerts())
• Abstrakte Klassen
  • In diesem Einführungsbeispiel sind keine Abstrakten Klassen vorhanden. Wird eine Klasse Abstrakt deklariert (Beispiel public abstract class Fahrzeug) kann diese Klasse nicht direkt Instanziiert werden, sondern dient nur als Vorlage für abgeleitete Klassen.

Gesamter Quellcode als Download (Visual Studio Projekt).

Dies ist ein kleines, einfaches und nicht so überladenes Beispiel welches ein ersten Einblick in die Vererbung welches bei der Objektorientierten Programmierung (OOP) ein Grundlegendes Konzept ist.
Viele Aufgaben des Programmierers wiederholen sich, ob es einfache Rechenaufgaben sind (wie z.B. die Mehrwertsteuer berechnen) oder wie hier in diesem Beispiel „Fahren“ ist. Es kann sich so an das DRY Prinzip gehalten werden (DRY = Don’t Repeat Yourself). In diesem Beispiel hier währen es die Methoden Hupen und FahreVorwaerts welche nicht doppelt geschrieben werden müssen. Das erleichtert die Wartung. Besitzt zum Beispiel die Methode Hupen() ein Fehler, muss diese nur 1x korrigiert werden damit alle Fahrzeuge den Fehler in der Methode Hupen korrigiert bekommen. Wenn wir die Methode Hupen in jeder Klasse (also Auto, Motorrad und LKW) hätten, müssten wir bei einem Fehlerfall diese Funktion 3x korrigieren.

Bei vielen größeren und älteren Programmen habe ich selber erleben müssen das sich einige Programmierer nicht an das DRY Prinzip gehalten haben, unter anderem auch weil ein Programm nicht mittels OOP erstellt worden ist. Gerade in Fremden Codes ist die
1. Wartbarkeit in diesem Moment schwer zu bewerkstelligen
2. Der Code ist unübersichtlich
3. Redundante Code-Duplikate erhöhen das Risiko für inkonsistente Änderungen.

Der Beitrag Grundlagen Vererbung erschien zuerst auf Gernardt.net.