C # - Verwendung von Schlüsselwörtern virtuell + überschreiben vs. neu

Was sind die Unterschiede zwischen dem Deklarieren einer Methode in einem Basistyp " virtual" und dem anschließenden Überschreiben in einem untergeordneten Typ mit dem overrideSchlüsselwort " " im Gegensatz zum einfachen Verwenden des newSchlüsselworts " " beim Deklarieren der übereinstimmenden Methode im untergeordneten Typ?

Das Schlüsselwort "new" überschreibt nicht, es kennzeichnet eine neue Methode, die nichts mit der Basisklassenmethode zu tun hat.

public class Foo
{
     public bool DoSomething() { return false; }
}

public class Bar : Foo
{
     public new bool DoSomething() { return true; }
}

public class Test
{
    public static void Main ()
    {
        Foo test = new Bar ();
        Console.WriteLine (test.DoSomething ());
    }
}

Dies gibt false aus. Wenn Sie überschreiben verwendet haben, wird true ausgegeben.

(Basiscode von Joseph Daigle)

Wenn Sie also echten Polymorphismus betreiben, sollten Sie IMMER ÜBERSCHREIBEN . Der einzige Ort, an dem Sie "new" verwenden müssen, ist, wenn die Methode in keiner Weise mit der Basisklassenversion zusammenhängt.

Ich finde solche Dinge mit Bildern immer leichter verständlich:

Wiederum den Code von Joseph Daigle nehmen,

public class Foo
{
     public /*virtual*/ bool DoSomething() { return false; }
}

public class Bar : Foo
{
     public /*override or new*/ bool DoSomething() { return true; }
}

Wenn Sie dann den Code wie folgt aufrufen:

Foo a = new Bar();
a.DoSomething();

HINWEIS: Das Wichtigste ist, dass unser Objekt tatsächlich ein Objekt ist Bar, aber wir speichern es in einer Variablen vom TypFoo (dies ähnelt dem Casting).

Das Ergebnis ist dann wie folgt, je nachdem, ob Sie virtual/ overrideoder newbei der Deklaration Ihrer Klassen verwendet haben.

Hier ist ein Code, um den Unterschied im Verhalten virtueller und nicht virtueller Methoden zu verstehen:

class A
{
    public void foo()
    {
        Console.WriteLine("A::foo()");
    }
    public virtual void bar()
    {
        Console.WriteLine("A::bar()");
    }
}

class B : A
{
    public new void foo()
    {
        Console.WriteLine("B::foo()");
    }
    public override void bar()
    {
        Console.WriteLine("B::bar()");
    }
}

class Program
{
    static int Main(string[] args)
    {
        B b = new B();
        A a = b;
        a.foo(); // Prints A::foo
        b.foo(); // Prints B::foo
        a.bar(); // Prints B::bar
        b.bar(); // Prints B::bar
        return 0;
    }
}

Das newSchlüsselwort erstellt tatsächlich ein völlig neues Mitglied, das nur für diesen bestimmten Typ vorhanden ist.

Zum Beispiel

public class Foo
{
     public bool DoSomething() { return false; }
}

public class Bar : Foo
{
     public new bool DoSomething() { return true; }
}

Die Methode existiert für beide Typen. Wenn Sie Reflection verwenden und die Mitglieder vom Typ Barabrufen, finden Sie tatsächlich zwei Methoden DoSomething(), die genau gleich aussehen. Durch die Verwendung newverstecken Sie die Implementierung in der Basisklasse effektiv, sodass, wenn Klassen von Bar(in meinem Beispiel) dem Methodenaufruf to abgeleitet werden, base.DoSomething()zu Barund nicht Foo.

virtual / override teilt dem Compiler mit, dass die beiden Methoden zusammenhängen und dass es unter bestimmten Umständen, wenn Sie glauben, die erste (virtuelle) Methode aufzurufen, tatsächlich richtig ist, stattdessen die zweite (überschriebene) Methode aufzurufen. Dies ist die Grundlage des Polymorphismus.

(new SubClass() as BaseClass).VirtualFoo()

Ruft die überschriebene VirtualFoo () -Methode der Unterklasse auf.

new teilt dem Compiler mit, dass Sie einer abgeleiteten Klasse eine Methode mit demselben Namen wie eine Methode in der Basisklasse hinzufügen, diese jedoch keine Beziehung zueinander haben.

(new SubClass() as BaseClass).NewBar()

Ruft die NewBar () -Methode der BaseClass auf, während:

(new SubClass()).NewBar()

Ruft die NewBar () -Methode der Unterklasse auf.

Über die technischen Details hinaus vermittelt die Verwendung von Virtual / Override meiner Meinung nach viele semantische Informationen zum Design. Wenn Sie eine Methode als virtuell deklarieren, geben Sie an, dass Sie erwarten, dass implementierende Klassen möglicherweise ihre eigenen, nicht standardmäßigen Implementierungen bereitstellen möchten. Wenn Sie dies in einer Basisklasse weglassen, wird ebenfalls die Erwartung deklariert, dass die Standardmethode für alle implementierenden Klassen ausreichen sollte. Ebenso kann man abstrakte Deklarationen verwenden, um implementierende Klassen zu zwingen, ihre eigene Implementierung bereitzustellen. Auch hier denke ich, dass dies viel darüber aussagt, wie der Programmierer erwartet, dass der Code verwendet wird. Wenn ich sowohl die Basis- als auch die Implementierungsklasse schreiben würde und neue verwenden würde, würde ich die Entscheidung, die Methode im übergeordneten Element nicht virtuell zu machen, ernsthaft überdenken und meine Absicht ausdrücklich erklären.

Der Unterschied zwischen dem Schlüsselwort override und dem neuen Schlüsselwort besteht darin, dass das erstere das Überschreiben von Methoden und das spätere das Ausblenden von Methoden ausführt.

Weitere Informationen finden Sie unter den folgenden Links ...

MSDN und andere

• newSchlüsselwort ist für Verstecken. - bedeutet, dass Sie Ihre Methode zur Laufzeit verstecken. Die Ausgabe basiert auf der Basisklassenmethode.
• overridezum Überschreiben. - bedeutet, dass Sie Ihre abgeleitete Klassenmethode mit der Referenz der Basisklasse aufrufen. Die Ausgabe basiert auf der abgeleiteten Klassenmethode.

Meine Version der Erklärung stammt aus der Verwendung von Eigenschaften , um die Unterschiede zu verstehen.

overrideist einfach genug, oder? Der zugrunde liegende Typ überschreibt den übergeordneten Typ .

newist vielleicht die irreführende (für mich war es). Mit Eigenschaften ist es einfacher zu verstehen:

public class Foo
{
    public bool GetSomething => false;
}

public class Bar : Foo
{
    public new bool GetSomething => true;
}

public static void Main(string[] args)
{
    Foo foo = new Bar();
    Console.WriteLine(foo.GetSomething);

    Bar bar = new Bar();
    Console.WriteLine(bar.GetSomething);
}

Mit einem Debugger können Sie feststellen , dass Foo foohat zwei GetSomething Eigenschaften, wie sie tatsächlich hat zwei Versionen der Immobilie, Foo‚s und Bar‘ s, und zu wissen , die man zu verwenden, c # ‚Picks‘ die Eigenschaft für den aktuellen Typen.

Wenn Sie die Version der Leiste verwenden möchten, hätten Sie Foo foostattdessen überschreiben oder verwenden .

Bar barhat nur 1 , da es für völlig neues Verhalten will GetSomething.

Eine Methode nicht mit irgendetwas zu markieren bedeutet: Binden Sie diese Methode mit dem Kompilierungstyp des Objekts, nicht mit dem Laufzeittyp (statische Bindung).

Markieren einer Methode mit virtualMitteln: Binden Sie diese Methode mit dem Laufzeittyp des Objekts und nicht mit dem Kompilierungszeittyp (dynamische Bindung).

Das Markieren einer Basisklassenmethode virtualmit overridein einer abgeleiteten Klasse bedeutet: Dies ist die Methode, die unter Verwendung des Laufzeittyps des Objekts gebunden werden soll (dynamische Bindung).

Das Markieren einer Basisklassenmethode virtualmit newin einer abgeleiteten Klasse bedeutet: Dies ist eine neue Methode, die keine Beziehung zu der Methode mit demselben Namen in der Basisklasse hat und unter Verwendung des Kompilierungszeittyps des Objekts (statische Bindung) gebunden werden sollte.

Das Nichtmarkieren einer Basisklassenmethode virtualin der abgeleiteten Klasse bedeutet: Diese Methode wird als new(statische Bindung) markiert .

Das Markieren einer Methode abstractbedeutet: Diese Methode ist virtuell, aber ich werde keinen Body dafür deklarieren und ihre Klasse ist auch abstrakt (dynamische Bindung).