new słowo kluczowe w sygnaturze metody

Podczas refaktoryzacji stworzyłem metodę taką jak na poniższym przykładzie. Typ danych został zmieniony ze względu na prostotę.

Wcześniej miałem takie oświadczenie przydziału:

MyObject myVar = new MyObject();

Zostało to refaktoryzowane przez przypadek:

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

Było to wynikiem mojego błędu wycinania / wklejania, ale newsłowo kluczowe w private static newjest prawidłowe i się kompiluje.

Pytanie : Co oznacza newsłowo kluczowe w sygnaturze metody? Zakładam, że to coś, co zostało wprowadzone w C # 3.0?

Czym to się różni override?

Nowe odniesienie do słów kluczowych z MSDN:

Dokumentacja MSDN

Oto przykład, który znalazłem w sieci od MVP firmy Microsoft, który miał sens: Link do oryginału

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

Zastąpienia można używać tylko w bardzo szczególnych przypadkach. Z MSDN:

Nie można przesłonić metody niewirtualnej ani statycznej. Zastąpiona metoda podstawowa musi być wirtualna, abstrakcyjna lub nadpisana.

Zatem słowo kluczowe „new” jest potrzebne, aby umożliwić „przesłonięcie” metod niewirtualnych i statycznych.

Nie, to właściwie nie jest „nowe” (przepraszam za kalambur). Zasadniczo jest używany do „ukrywania” metody. TO ZNACZY:

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

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

Jeśli to zrobisz:

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

Metoda w Base to ta, która zostanie wywołana, a NIE ta w wyprowadzonej.

Więcej informacji: http://www.akadia.com/services/dotnet_polymorphism.html

Re twoja edycja: W podanym przeze mnie przykładzie, gdybyś miał "przesłonić" zamiast używać "nowy", a następnie wywołać b.Method (); Metoda klasy pochodnej zostanie nazwana z powodu polimorfizmu.

Jak wyjaśnili inni, służy do ukrycia istniejącej metody. Jest to przydatne do przesłonięcia metody, która nie jest wirtualna w klasie nadrzędnej.

Pamiętaj, że tworzenie „nowego” elementu nie jest polimorficzne. Jeśli rzutujesz obiekt na typ podstawowy, nie będzie on używał elementu członkowskiego typu pochodnego.

Jeśli masz klasę bazową:

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

A następnie klasa pochodna:

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

}

Jeśli zadeklarujesz typ, DerivedTypea następnie go wyrzucisz, metoda DoSomething()nie jest polimorficzna, wywoła metodę klasy bazowej, a nie pochodną.

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

Z dokumentów:

Jeśli metoda w klasie pochodnej jest poprzedzona słowem kluczowym new, metoda jest definiowana jako niezależna od metody w klasie bazowej.

Co to oznacza w praktyce:

Jeśli dziedziczysz z innej klasy i masz metodę, która ma ten sam podpis, możesz zdefiniować ją jako „nową”, aby była niezależna od klasy nadrzędnej. Oznacza to, że jeśli masz odwołanie do klasy „nadrzędnej”, to ta implementacja zostanie wykonana, jeśli masz odwołanie do klasy podrzędnej, to ta implementacja zostanie wykonana.

Osobiście staram się unikać słowa kluczowego „nowe”, ponieważ zwykle oznacza to, że mam błędną hierarchię klas, ale czasami może się to przydać. Jedno miejsce służy do wersjonowania i kompatybilności wstecznej.

W witrynie MSDN jest wiele informacji na ten temat .

Oznacza to, że metoda zastępuje metodę o tej samej nazwie odziedziczonej przez klasę bazową. W twoim przypadku prawdopodobnie nie masz metody o tej nazwie w klasie bazowej, co oznacza, że ​​nowe słowo kluczowe jest całkowicie zbędne.

Krótko mówiąc - NIE jest to wymagane, NIE zmienia zachowania i jest CAŁKOWICIE tam dla czytelności.

Dlatego w VS zobaczysz trochę zawijanie, ale twój kod będzie kompilował się i działał idealnie dobrze i zgodnie z oczekiwaniami.

Można się zastanawiać, czy naprawdę warto było stworzyć newsłowo kluczowe, skoro wszystko to oznacza, że ​​programista przyznał: „Tak, wiem, że ukrywam metodę podstawową, tak wiem, że nie robię nic związanego z virtuallub overriden(polimorfizm) - Naprawdę chcę po prostu stworzyć własną metodę ”.

Jest to dla mnie trochę dziwne, ale może tylko dlatego, że pochodzę z Javatła i istnieje podstawowa różnica między C#dziedziczeniem a Java: W Javametodach są domyślnie wirtualne, chyba że określono to w final. W programie C#metody są domyślnie końcowe / konkretne, chyba że określono to w virtual.

Z MSDN :

Użyj nowego modyfikatora, aby jawnie ukryć element członkowski odziedziczony z klasy bazowej. Aby ukryć dziedziczony element członkowski, zadeklaruj go w klasie pochodnej przy użyciu tej samej nazwy i zmodyfikuj go za pomocą nowego modyfikatora.

Uważaj na tę łapkę.
Masz metodę zdefiniowaną w interfejsie, który jest zaimplementowany w klasie bazowej. Następnie tworzysz klasę pochodną, ​​która ukrywa metodę interfejsu, ale nie deklarujesz konkretnie klasy pochodnej jako implementującej interfejs. Jeśli następnie wywołasz metodę za pośrednictwem odwołania do interfejsu, zostanie wywołana metoda klasy bazowej. Jeśli jednak klasa pochodna konkretnie implementuje interfejs, jej metoda zostanie wywołana niezależnie od używanego typu odwołania.

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();

    }
}