neues Schlüsselwort in der Methodensignatur

Während eines Refactorings habe ich eine Methode wie das folgende Beispiel erstellt. Der Datentyp wurde der Einfachheit halber geändert.

Ich hatte vorher eine Zuweisungserklärung wie diese:

MyObject myVar = new MyObject();

Es wurde versehentlich umgestaltet:

private static new MyObject CreateSomething()
{
  return new MyObject{"Something New"};
}

Dies war das Ergebnis eines Fehlers beim Ausschneiden / Einfügen von meiner Seite, aber das newSchlüsselwort in private static newist gültig und wird kompiliert.

Frage : Was bedeutet das newSchlüsselwort in einer Methodensignatur? Ich nehme an, es ist etwas, das in C # 3.0 eingeführt wurde.

Wie unterscheidet sich das von override?

Neue Keyword-Referenz von MSDN:

MSDN-Referenz

Hier ist ein Beispiel, das ich im Internet von einem Microsoft MVP gefunden habe, das Sinn gemacht hat: Link zum Original

public class A
{
   public virtual void One();
   public void Two();
}

public class B : A
{
   public override void One();
   public new void Two();
}

B b = new B();
A a = b as A;

a.One(); // Calls implementation in B
a.Two(); // Calls implementation in A
b.One(); // Calls implementation in B
b.Two(); // Calls implementation in B

Override kann nur in ganz bestimmten Fällen verwendet werden. Von MSDN:

Sie können eine nicht virtuelle oder statische Methode nicht überschreiben. Die überschriebene Basismethode muss virtuell, abstrakt oder überschrieben sein.

Daher wird das Schlüsselwort "new" benötigt, damit Sie nicht virtuelle und statische Methoden "überschreiben" können.

Nein, es ist eigentlich nicht "neu" (entschuldigen Sie das Wortspiel). Es wird im Grunde genommen verwendet, um eine Methode zu "verstecken". IE:

public class Base
{
   public virtual void Method(){}
}

public class Derived : Base
{
   public new void Method(){}
}

Wenn Sie dann dies tun:

Base b = new Derived();
b.Method();

Die Methode in der Base wird aufgerufen, NICHT die in der abgeleiteten.

Weitere Informationen: http://www.akadia.com/services/dotnet_polymorphism.html

Zu Ihrer Bearbeitung: In dem Beispiel, das ich gegeben habe, wenn Sie "überschreiben" anstatt "neu" zu verwenden, dann, wenn Sie b.Method () aufrufen; Die Methode der abgeleiteten Klasse würde wegen Polymorphismus aufgerufen.

Wie andere erklärt haben, wird es verwendet, um eine vorhandene Methode auszublenden. Dies ist nützlich, um eine Methode zu überschreiben, die in der übergeordneten Klasse nicht virtuell ist.

Beachten Sie, dass das Erstellen eines "neuen" Elements nicht polymorph ist. Wenn Sie das Objekt in den Basistyp umwandeln, wird das Mitglied des abgeleiteten Typs nicht verwendet.

Wenn Sie eine Basisklasse haben:

public class BaseClass
{
    public void DoSomething() { }
}

Und dann die abgeleitete Klasse:

public class DerivedType : BaseClass
{
    public new void DoSomething() {}

}

Wenn Sie einen Typ von deklarieren DerivedTypeund dann umwandeln, ist die Methode DoSomething()nicht polymorph, sondern ruft die Methode der Basisklasse auf, nicht die abgeleitete.

BaseClass t = new DerivedType();
t.DoSomething();// Calls the "DoSomething()" method of the base class.

Aus den Dokumenten:

Wenn der Methode in der abgeleiteten Klasse das neue Schlüsselwort vorangestellt wird, wird die Methode als unabhängig von der Methode in der Basisklasse definiert.

Was dies in der Praxis bedeutet:

Wenn Sie von einer anderen Klasse erben und über eine Methode verfügen, die dieselbe Signatur verwendet, können Sie sie als "neu" definieren, damit sie unabhängig von der übergeordneten Klasse ist. Dies bedeutet, dass diese Implementierung ausgeführt wird, wenn Sie einen Verweis auf die übergeordnete Klasse haben. Wenn Sie einen Verweis auf die untergeordnete Klasse haben, wird diese Implementierung ausgeführt.

Persönlich versuche ich, das 'neue' Schlüsselwort zu vermeiden, da es normalerweise bedeutet, dass meine Klassenhierarchie falsch ist, aber es gibt Zeiten, in denen es nützlich sein kann. Ein Ort ist für die Versionierung und Abwärtskompatibilität.

Dafür gibt es im MSDN viele Informationen .

Dies bedeutet, dass die Methode eine Methode mit demselben Namen ersetzt, die von der Basisklasse geerbt wurde. In Ihrem Fall haben Sie wahrscheinlich keine Methode mit diesem Namen in der Basisklasse, was bedeutet, dass das neue Schlüsselwort völlig überflüssig ist.

Lange Rede, kurzer Sinn - es ist NICHT erforderlich, es ändert KEIN Verhalten und es ist REIN für die Lesbarkeit da.

Aus diesem Grund werden Sie in VS ein wenig schnörkellos sehen, aber Ihr Code wird kompiliert und läuft einwandfrei und wie erwartet.

Man muss sich fragen, ob es sich wirklich gelohnt hat, das newSchlüsselwort zu erstellen, wenn der Entwickler lediglich bestätigt: "Ja, ich weiß, dass ich eine Basismethode verstecke, ja, ich weiß, dass ich nichts im Zusammenhang mit virtualoder overriden(Polymorphismus) mache. Ich möchte wirklich nur eine eigene Methode erstellen ".

Es ist ein bisschen bizarr für mich, aber vielleicht nur, weil ich aus einem JavaHintergrund komme und es diesen grundlegenden Unterschied zwischen C#Vererbung und Java: In gibt Java, sind Methoden standardmäßig virtuell, sofern nicht anders angegeben final. In C#sind Methoden standardmäßig final / konkret, sofern nicht anders angegeben virtual.

Von MSDN :

Verwenden Sie den neuen Modifikator, um ein von einer Basisklasse geerbtes Mitglied explizit auszublenden. Um ein geerbtes Mitglied auszublenden, deklarieren Sie es in der abgeleiteten Klasse mit demselben Namen und ändern Sie es mit dem neuen Modifikator.

Sei vorsichtig mit diesem Gotcha.
Sie haben eine Methode in einer Schnittstelle definiert, die in einer Basisklasse implementiert ist. Anschließend erstellen Sie eine abgeleitete Klasse, die die Methode der Schnittstelle verbirgt, die abgeleitete Klasse jedoch nicht speziell als Implementierung der Schnittstelle deklariert. Wenn Sie die Methode dann über einen Verweis auf die Schnittstelle aufrufen, wird die Methode der Basisklasse aufgerufen. Wenn Ihre abgeleitete Klasse die Schnittstelle jedoch speziell implementiert, wird ihre Methode unabhängig von der verwendeten Referenzart aufgerufen.

interface IMethodToHide
{
    string MethodToHide();
}

class BaseWithMethodToHide : IMethodToHide
{
    public string MethodToHide()
    {
        return "BaseWithMethodToHide";
    }
}

class DerivedNotImplementingInterface   : BaseWithMethodToHide
{
    new public string MethodToHide()
    {
        return "DerivedNotImplementingInterface";
    }
}

class DerivedImplementingInterface : BaseWithMethodToHide, IMethodToHide
{
    new public string MethodToHide()
    {
        return "DerivedImplementingInterface";
    }
}

class Program
{
    static void Main()
    {
        var oNoI = new DerivedNotImplementingInterface();
        IMethodToHide ioNoI = new DerivedNotImplementingInterface();

        Console.WriteLine("reference to the object type DerivedNotImplementingInterface calls the method in the class " 
            + oNoI.MethodToHide());
        // calls DerivedNotImplementingInterface.MethodToHide()
        Console.WriteLine("reference to a DerivedNotImplementingInterface object via the interfce IMethodToHide calls the method in the class " 
            + ioNoI.MethodToHide());
        // calls BaseWithMethodToHide.MethodToHide()
        Console.ReadLine();

        var oI = new DerivedImplementingInterface();
        IMethodToHide ioI = new DerivedImplementingInterface();

        Console.WriteLine("reference to the object type DerivedImplementingInterface calls the method in the class " 
            + oI.MethodToHide());
        // calls DerivedImplementingInterface.MethodToHide()
        Console.WriteLine("reference to a DerivedImplementingInterface object via the interfce IMethodToHide calls the method in the class " 
            + ioI.MethodToHide());
        // calls DerivedImplementingInterface.MethodToHide()
        Console.ReadLine();

    }
}