C# new vs override

1. Das Schlüsselwort new in C#
2. das Schlüsselwort override in C#

In diesem Tutorial wird der Unterschied zwischen den Schlüsselwörtern new und override in C# erläutert.

Das Schlüsselwort new in C#

Das Schlüsselwort new ist in C# sehr verbreitet. Traditionell kann es an drei verschiedenen Stellen verwendet werden: Operator, Modifikator und Einschränkung.

Die erste und beliebteste Verwendung des Schlüsselworts new ist die Verwendung als Operator zum Erstellen von Klassenobjekten und zum Aufrufen ihrer Klassenkonstruktoren in C#. Mit dem Schlüsselwort new werden wertartige Objekte wie int und float im Stack und referenzartige Objekte wie benutzerdefinierte Klassen im Heap erzeugt.

Einige Dinge, die Sie bei der Verwendung des Schlüsselworts new als Operator beachten sollten, sind: Es weist dem Objekt nur den Speicher zu und zerstört keinen Speicher, der zuvor von demselben Bereich abhängig war, und wir können die Funktionalität des Schlüsselworts nicht überschreiben new Schlüsselwort in C#.

Zweitens verbirgt es bei Verwendung des Schlüsselworts new als Modifikator die von der abgeleiteten Klasse geerbten Basisklassenmitglieder. Die vorherige Anweisung bedeutet, dass anstelle des Überschreibens oder Deklarierens einer neuen Definition dieses geerbten Klassenmitglieds das Schlüsselwort new die vorherige Definition dieses Mitglieds in der Basisklasse ersetzt.

Die dritte Verwendung des Schlüsselworts new ist im Vergleich zu den beiden vorherigen relativ ungewöhnlich. Während wir das Schlüsselwort new als Einschränkung verwenden, geben wir an, dass der generische Typ einen öffentlichen Konstruktor ohne zusätzliche Parameter haben muss.

Der Nachteil dieses Ansatzes ist, dass wir ihn nicht mit einem abstrakten Typ verwenden können.

Für dieses Tutorial verwenden wir das Schlüsselwort new als Modifikator, um die Definition der Basisklasse vor der abgeleiteten Klasse zu verbergen. In C# verbirgt der Compiler standardmäßig implizit die Definition aller geerbten Funktionen.

Das folgende Code-Snippet zeigt, wie wir die Definition einer geerbten Funktion mit dem Schlüsselwort new explizit vor der abgeleiteten Klasse verbergen können.

public class BaseClass {
  public virtual void fun() {
    Console.WriteLine("Base class");
  }
}

public class DerivedClass : BaseClass {
  public new void fun() { Console.WriteLine("Derived class");
}
public static void Main(string[] args) {
  BaseClass b = new BaseClass();
  DerivedClass d = new DerivedClass();
  BaseClass bd = new DerivedClass();
  b.fun();
  d.fun();
  bd.fun();
}
}

Ausgabe:

Base class
Derived class
Base class

Die Ausgabe für die ersten beiden Objekte ist ziemlich einfach; das BaseClass-Objekt b verweist auf die fun()-Funktion innerhalb der Basisklasse und das DerivedClass-Objekt d verweist auf die fun()-Funktion innerhalb der abgeleiteten Klasse.

Eine sehr interessante Sache passiert, wenn wir die Referenz der abgeleiteten Klasse einem Objekt der Basisklasse bd zuweisen und die Funktion fun() aufrufen. Die Funktion fun() innerhalb der Basisklasse wird diesmal trotzdem ausgeführt.

Dies liegt daran, dass die Implementierung der Funktion fun() innerhalb der Basisklasse vor der abgeleiteten Klasse verborgen ist.

Dasselbe Ziel kann auch ohne das Schlüsselwort new erreicht werden. Das folgende Code-Snippet zeigt, wie wir dasselbe Ziel erreichen können, ohne das Schlüsselwort new zu verwenden.

public class BaseClass {
  public virtual void fun() {
    Console.WriteLine("Base class");
  }
}

public class DerivedClass : BaseClass {
  public void fun() {
    Console.WriteLine("Derived class");
  }
  public static void Main(string[] args) {
    BaseClass b = new BaseClass();
    DerivedClass d = new DerivedClass();
    BaseClass bd = new DerivedClass();
    b.fun();
    d.fun();
    bd.fun();
  }
}

Ausgabe:

Base class
Derived class
Base class

Beachten Sie, dass die Ausgabe dieselbe ist wie beim vorherigen Ansatz. Der einzige Unterschied besteht hier darin, dass wir dieses Mal eine Compiler-Warnung erhalten, die besagt, dass zum expliziten Ausblenden des Klassenmitglieds das Schlüsselwort new verwendet werden soll.

das Schlüsselwort override in C#

In C# erweitert der Modifikator override die geerbte Methode von der Basisklasse. Das Schlüsselwort override stellt eine neue Implementierung der von der Basisklasse geerbten Methode virtual bereit.

Eine Sache, die hier zu beachten ist, ist, dass wir das Schlüsselwort override nicht verwenden können, um eine nicht-virtuelle oder statische Methode zu erweitern. Die Funktion in der Basisklasse muss virtuell oder abstrakt sein oder von einer anderen Superklasse überschrieben werden.

Im Zusammenhang mit unserem vorherigen Beispiel zeigt das folgende Code-Snippet, wie wir den Modifikator override verwenden können, um die Funktionalität einer von der Basisklasse geerbten virtual Funktion zu erweitern.

public class BaseClass {
  public virtual void fun() {
    Console.WriteLine("Base class");
  }
}

public class DerivedClass : BaseClass {
  public override void fun() {
    Console.WriteLine("Derived class");
  }
  public static void Main(string[] args) {
    BaseClass b = new BaseClass();
    DerivedClass d = new DerivedClass();
    BaseClass bd = new DerivedClass();
    b.fun();
    d.fun();
    bd.fun();
  }
}

Ausgabe:

Base class
Derived class
Derived class

Die Ausgabe für die ersten beiden Objekte ist ziemlich einfach; das BaseClass-Objekt b verweist auf die fun()-Funktion innerhalb der Basisklasse und das DerivedClass-Objekt d verweist auf die fun()-Funktion innerhalb der abgeleiteten Klasse.

Der eigentliche Unterschied zum Schlüsselwort new zeigt sich, wenn wir die Referenz der abgeleiteten Klasse einem Objekt der Basisklasse bd zuweisen und die Funktion fun() aufrufen. Im Gegensatz zu den beiden vorherigen Beispielen wird diesmal die Funktion fun() der abgeleiteten Klasse aufgerufen.

Das Schlüsselwort override wird verwendet, um die untergeordnete Implementierung einer virtuellen Funktion für ihr übergeordnetes Objekt anzuzeigen, während das Schlüsselwort new verwendet wird, um die untergeordnete Implementierung vor ihrem übergeordneten Klassenobjekt zu verbergen.