C# virtual vs. abstract

Wenn man in C# an mehr oder weniger großen Projekten programmiert, wird man früher oder später auf Klassen und Methoden stoßen, die einen speziellen Modifizierer vorangestellt haben, wie die Modifizierer abstract und virtual. Dabei ist es nicht gleich einleuchtend, worin der Unterschied zwischen abstract und virtual besteht.

Abstrakte Klassen

Ein wesentliches Merkmal ist, dass es abstrakte Klassen geben kann, die den Modifizierer abstract vorangestellt haben können. Es gibt aber keine virtuellen Klassen. Neben abstract können Klassen auch noch die Modifizierer static, sealed und partial vorangestellt haben.

Erstellt man eine abstrakte Klasse, so bestimmt man damit, wie diese sich im Rahmen der Vererbung verhält. Von einer abstrakten Klasse lassen sich keine Instanzen bilden. Die abstrakte Klasse definiert somit nur das Grundgerüst für die zu vererbenden Eigenschaften an eine abgeleitete Klasse.

Fürs Verständnis könnte eine solche Klasse zum Beispiel Tier (Animal) heißen, welche das Grundgerüst vorgibt und von welcher dann alle weiteren Tierklassen, z.B. Vogel (Bird) abgeleitet werden.

public abstract class Animal
{
    public string? Name { get; set; }
    public int Age { get; set; }
    public abstract void Eat();
    public abstract void Sleep();
}

public class Bird:Animal
{
    public override void Eat()
    {
        Debug.WriteLine("Bird Eat");
    }

    public override void Sleep()
    {
        Debug.WriteLine("Bird Sleep");
    }
    public Bird()
    {
        Name = "Bird";
        Age = 1;
    }
}

Man sieht, innerhalb der Klasse werden auch abstrakte Methoden definiert. Damit es zu keinem Compiler-Fehler kommt, müssen in den abgeleiteten Klassen ebenfalls die als abstrakt definierten Methoden implementiert werden. Dadurch haben abstrakte Klassen eine sehr große Ähnlichkeit mit Interfaces.

Abstrakte Methoden

In dem Code-Beispiel oben haben wir gesehen, dass auch Methoden als abstract definiert werden können. Solche abstrakten Methoden enthalten keinen Code und müssen in der abgeleiteten Klasse überschrieben werden mit override und implementiert werden. Siehe Code-Beispiel oben, wo wir als Implementierung nur eine Konsolen-Ausgabe mit WriteLine machen.

Die abstrakten Methoden sind immer Bestandteil einer abstrakten Klasse.

Virtuelle Methoden

Den Bezeichner virtual setzt man immer dann vor eine Methode, wenn diese von einer abgeleiteten Klasse überschrieben werden kann. Der große Unterschied zu abstract ist, dass eine virtuelle Methode implementiert wird, das heißt also bereits Code enthält. Außerdem kann eine virtuelle Methode sowohl in abstrakten Klassen als auch in normalen Klassen verwendet werden. Wir verdeutlichlichen dieses Verhalten, in dem wir das Code-Beispiel von oben um die virtuelle Methode Move() erweitern.

public abstract class Animal
{
    public string? Name { get; set; }
    public int Age { get; set; }
    public abstract void Eat();
    public abstract void Sleep();
    public virtual void Move()
    {
        Console.WriteLine("Animal Move");
    }
}

public class Bird:Animal
{
    public override void Eat()
    {
        Debug.WriteLine("Bird Eat");
    }

    public override void Sleep()
    {
        Debug.WriteLine("Bird Sleep");
    }
    public Bird()
    {
        Name = "Bird";
        Age = 1;
    }
    public override void Move()
    {
        Debug.WriteLine("Bird is jumping");
    }
}

In der abgeleiteten Klasse kann die virtuelle Methode überschrieben werden, muss aber nicht überschrieben werden.

Unterschiede zwischen abstract und virtual zusammengefasst

• abstract kann als Modifizierer für Klassen verwendet werden; virtual nicht
• abstract und virtual können Methoden vorangestellt werden
• abstrakte Methoden sind Bestandteil von abstrakten Klassen
• virtuelle Methoden können Bestandteil von abstrakten und normalen Klassen sein
• abstrakte Methoden enthalten keinen Code und müssen in der abgeleiteten Klasse überschrieben werden
• virtuelle Methoden enthalten Coden und können in abgeleiteten Klassen überschrieben werden