neues Schlüsselwort in der Methodensignatur

Question

Bei der Durchführung eines Refactorings habe ich eine Methode wie das folgende Beispiel erstellt. Der Datentyp wurde der Einfachheit halber geändert.

Ich hatte früher eine Aufgabe wie diese:

MyObject myVar = new MyObject();

Sie wurde versehentlich in diese Richtung umstrukturiert:

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

Dies war das Ergebnis eines Cut/Paste-Fehlers meinerseits, aber die new Schlüsselwort in private static new gültig und kompilierbar ist.

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

Wie unterscheidet sich dies von override ?

Answer 1

Das 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, so dass das Schlüsselwort new völlig überflüssig ist.

Answer 2

Desde MSDN :

Verwenden Sie den neuen Modifikator, um ein von einer Basisklasse geerbtes Mitglied explizit auszublenden Basisklasse zu verbergen. Um ein geerbtes Mitglied zu verstecken, deklarieren Sie es in der abgeleiteten Klasse unter demselben Namen deklariert und mit dem Modifikator new modifiziert.

Answer 3

Seien Sie vorsichtig mit dieser Masche.
Sie haben eine Methode in einer Schnittstelle definiert, die in einer Basisklasse implementiert ist. Sie erstellen dann eine abgeleitete Klasse, die die Methode der Schnittstelle ausblendet, aber die abgeleitete Klasse nicht ausdrücklich als Implementierung der Schnittstelle deklariert. Wenn Sie dann die Methode über einen Verweis auf die Schnittstelle aufrufen, wird die Methode der Basisklasse aufgerufen. Wenn Ihre abgeleitete Klasse die Schnittstelle jedoch ausdrücklich implementiert, wird ihre Methode unabhängig vom Typ der Referenz 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();

    }
}

Answer 4

FWIW, ich habe C#-Code für eine ganze Weile jetzt schreiben, und der einzige Fall, wo ich brauchte die new Schlüsselwort war das folgende OO-Hierarchie-Szenario:

public abstract class Animal
{
    protected Animal(Animal mother, Animal father)
    {
        Mother = mother;
        Father = father;
    }

    public Animal Mother { get; }
    public Animal Father { get; }
}

public class Dog : Animal
{
    public Dog(Dog mother, Dog father)
        : base(mother, father)
    {
    }

    public new Dog Mother => (Dog)base.Mother;
    public new Dog Father => (Dog)base.Father;
}

Einige wenige Bemerkungen:

• Es wird keine OO-Regel gebrochen, die Basisklassen funktionieren weiterhin einwandfrei.
• Eigenschaften sind nicht markiert virtual absichtlich, sie müssen es nicht sein.
• Dank des neuen Schlüsselworts "a dog" setzen wir sogar noch mehr OO-Regeln durch. kann nicht irgendein Tier als Vater/Mutter haben. Es muss ein Hund sein.
• die new Schlüsselwort wird verwendet, weil wir eine Eigenschaft (oder Methode) nicht einfach "überschreiben" können, indem wir ihren Rückgabetyp ändern. new ist die einzige Möglichkeit, eine schöne OO-Hierarchie zu haben.