Virtuelles Schlüsselwort in C#

Was ist das virtuelle Schlüsselwort? Bevor Sie direkt in die C#-Perspektive einsteigen, ist es wichtig, das Konzept der Vererbung, des Überschreibens und des virtuellen Schlüsselworts in der Welt der objektorientierten Programmierung zu verstehen oder zu überarbeiten.

Methodenüberschreibung ist ein OOPs-Konzept, das eng mit der Vererbung verknüpft ist. Wenn eine untergeordnete Klassenmethode die übergeordnete Klassenmethode mit demselben Namen, denselben Parametern und demselben Rückgabetyp überschreibt, wird dies als Methodenüberschreibung bezeichnet. Ein virtuelles Schlüsselwort ist ein Hinweis für den Compiler, dass eine Methode in abgeleiteten Klassen überschrieben werden kann.

Aus der C#-Perspektive wird das Schlüsselwort virtual verwendet, um die Deklaration einer Eigenschaft, Methode oder eines Ereignisses zu ändern, um das Überschreiben in einer abgeleiteten Klasse zu ermöglichen. Vereinfacht ausgedrückt implementiert das Schlüsselwort virtual das Methodenüberschreibungskonzept in C#.

Syntax

Jede Eigenschaft, Methode oder jedes Ereignis kann überschrieben werden, indem das Schlüsselwort virtual in der Basisklasse und das Schlüsselwort override in der abgeleiteten Klasse hinzugefügt wird.

Fügen Sie das virtuelle Schlüsselwort in der Basisklassendeklaration hinzu:

public class Base {
public virtual int abc { get; set; } // this property can be overridden
public virtual void Xyz() { }         // this method can be overridden
}

Fügen Sie das Schlüsselwort override in der Basisklassendeklaration hinzu:

public class Derived : Base {
public override int abc { get; set; } // this overrides the base class property
public override void Xyz() { }        // this overrides the base class method
}

Wie funktioniert Virtual in C#?

Der grundlegende Unterschied zwischen Überladen und Überschreiben besteht darin, dass Ersteres ein Mechanismus zur Kompilierungszeit ist, während Letzteres zur Laufzeit ins Spiel kommt. Ein virtuelles Schlüsselwort tritt zur Laufzeit in Aktion und implementiert so das Methodenüberschreibungskonzept.

Wenn eine virtuelle Methode oder Eigenschaft aufgerufen oder darauf zugegriffen wird, prüft der Compiler, ob ein überschreibendes Mitglied der Methode oder Eigenschaft vorhanden ist. Wenn einer gefunden wird, wird er aufgerufen. Wenn keine gefunden wird, wird die ursprüngliche Methode oder Eigenschaft aufgerufen.

Hier stellt sich eine hervorragende Frage: Was passiert bei einer mehrstufigen Vererbung? Wenn ein Klassenmitglied auf mehr als einer Ebene überschrieben wird, wird das am tiefsten überschriebene Mitglied aufgerufen (das in der am stärksten abgeleiteten Klasse).

Beispiel

Das folgende Beispiel eines virtuellen Schlüsselworts in C# wird unten erwähnt

Einstufige Vererbung

Nehmen wir ein Beispiel, um die Funktionsweise eines virtuellen Schlüsselworts zu verstehen, wenn eine einzelne untergeordnete Klasse die übergeordnete Klasse erbt, d. h. es gibt keine mehrstufige Vererbung.

Code:

using System;
public class Polynomial
{
public virtual double len
{
get;
set;
}
public virtual double wid
{
get;
set;
}
public virtual double Area()
{
return len * wid;
}
}
public class Rectangle: Polynomial
{
}
public class Square : Polynomial
{
public override double len
{
get;
set;
}
public override double Area()
{
return len * len;
}
}
public class Circle : Polynomial
{
public double radius
{
get;
set;
}
public override double Area()
{
return Math.PI * radius * radius;
}
}
public class Triangle : Polynomial
{
public override double Area()
{
return 0.5 * len * wid;
}
}
public class Program
{
public static void Main()
{
var rect = new Rectangle();
rect.len = 5;
rect.wid = 10;
Console.WriteLine("Area of Rectangle = " + rect.Area());
var sq = new Square();
sq.len = 15;
Console.WriteLine("Area of Square = " + sq.Area());
var cir = new Circle();
cir.radius = 10;
Console.WriteLine("Area of Circle = " + cir.Area());
var tri = new Triangle();
tri.len = 5;
tri.wid = 10;
Console.WriteLine("Area of Triangle = " + tri.Area());
}
}

Ausgabe:

Wie funktioniert der obige Code?

In der Basisklasse Polynomial haben wir zwei Eigenschaften und eine Methode als virtuell deklariert. Diese können nun in untergeordneten Klassen überschrieben werden. Jetzt erstellen wir verschiedene untergeordnete Klassen unterschiedlicher Form, die die Polynomklasse erben.

In der Klasse „Rechteck“ müssen wir keine Eigenschaft oder Methode überschreiben. Die Basisklassenimplementierung würde unverändert für die Rechteckklasse funktionieren.

In der Square-Klasse haben wir nicht die Eigenschaft width. Also überschreiben wir die Längeneigenschaft und die Flächenmethode, um das Quadrat der Länge zurückzugeben.

In der Circle-Klasse haben wir weder Länge noch Breite. Daher deklarieren wir eine neue klassenspezifische Eigenschaft des Radius und überschreiben die Area-Methode entsprechend.

In der Triangle-Klasse überschreiben wir einfach die Area-Methode und die Eigenschaften werden von der Basisklasse Polynomial geerbt.

Wenn wir Objekte der abgeleiteten Klassen erstellen, stößt der Compiler während der Basisklassenkonstruktion auf das Schlüsselwort virtual und sucht daher nach den überschriebenen Mitgliedern. Die überschriebenen Mitglieder werden dann entsprechend aufgerufen.

Mehrstufige Vererbung

Lassen Sie uns das obige Beispiel modifizieren, um die mehrstufige Vererbung einzubeziehen.

Code:

using System;
public class Polynomial
{
public virtual double len {       get; set; }
public virtual double wid {       get; set; }
public virtual double Area()
{ return 0; }
}
public class Rectangle : Polynomial
{
public override double Area()
{ return len * wid; }
}
public class Square : Rectangle
{
public override double len { get; set; }
public override double Area()
{ return len * len; }
}
public class Program
{
public static void Main()
{
var rect = new Rectangle();
rect.len = 5;
rect.wid = 10;
Console.WriteLine("Area of Rectangle = " + rect.Area());
var sq = new Square();
sq.len = 15;
Console.WriteLine("Area of Square = " + sq.Area());
}
}

Ausgabe:

Vorteile

Ein virtuelles Mitglied verfügt über Deklarationen und Definitionen sowohl in der Basisklasse als auch in abgeleiteten Klassen. Virtuelle Mitglieder sind von Vorteil, wenn in den abgeleiteten Klassen einige zusätzliche Funktionen erforderlich sind. Sie dienen als Add-ons.

Regeln

• Eine Variable kann nicht als virtuell deklariert werden. Nur Eigenschaften, Methoden und Ereignisse können als virtuell deklariert werden.
• Ein statisches Mitglied kann nicht als virtuell deklariert werden.
• Ein abstraktes Mitglied kann nicht als virtuell deklariert werden.
• Ein privates Mitglied kann nicht als virtuell deklariert werden.
• Ein nicht virtuelles Mitglied kann nicht überschrieben werden.
• Die Zugriffsebene, der Typ und der Name der virtuellen Mitglieder und der übergeordneten Mitglieder müssen gleich sein. Wenn beispielsweise die virtuelle Methode öffentlich ist, muss die überschreibende Methode ebenfalls öffentlich sein.

Fazit

In diesem Artikel haben wir das Konzept von virtuell in C# verstanden. Wir haben gesehen, wie C# das Schlüsselwort virtual zur Laufzeit implementiert und haben uns die Beispiele angesehen.

Virtuelle Member sind ein großartiges Konzept der objektorientierten Programmierung. Um jedoch tiefergehende Kenntnisse zu erlangen, wird dringend empfohlen, sich mit abstrakten Schlüsselwörtern, Schnittstellen und neuen Schlüsselwörtern vertraut zu machen. Dies würde sehr dabei helfen, den Unterschied zwischen ihnen allen zu verstehen. Dies hilft dabei, zu erkennen, wann Sie virtuelle Inhalte verwenden sollten und wann nicht.

Das obige ist der detaillierte Inhalt vonVirtuelles Schlüsselwort in C# . Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!