yöntem imzasında yeni anahtar kelime

Yeniden düzenleme yaparken, aşağıdaki örnekteki gibi bir yöntem oluşturdum. Veri türü basitlik uğruna değiştirildi.

Daha önce şöyle bir atama bildirimim vardı:

MyObject myVar = new MyObject();

Bu duruma tesadüfen yeniden düzenlenmiştir:

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

Bu benim açımdan bir kesme / yapıştırma hatasının bir sonucuydu, ancak in newanahtar kelimesi private static newgeçerlidir ve derlenir.

Soru : newAnahtar sözcük, yöntem imzasında neyi ifade eder ? C # 3.0'da tanıtılan bir şey olduğunu varsayıyorum?

Bu nasıl farklıdır override?

MSDN'den yeni anahtar kelime referansı:

MSDN Referansı

İşte bir Microsoft MVP'den internette bulduğum iyi bir örnek: Link to 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

Geçersiz kılma yalnızca çok özel durumlarda kullanılabilir. MSDN'den:

Sanal olmayan veya statik bir yöntemi geçersiz kılamazsınız. Geçersiz kılınan temel yöntem sanal, soyut veya geçersiz kılma olmalıdır.

Dolayısıyla, sanal olmayan ve statik yöntemleri "geçersiz kılmanıza" izin vermek için "yeni" anahtar kelimesine ihtiyaç vardır.

Hayır, aslında "yeni" değil (kelime oyununu bağışlayın). Temelde bir yöntemi "gizlemek" için kullanılır. IE:

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

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

Bunu yaparsanız:

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

Base'deki yöntem, türetilen yöntem DEĞİL, çağrılacak olan yöntemdir.

Biraz daha bilgi: http://www.akadia.com/services/dotnet_polymorphism.html

Düzenlemeniz yeniden: Verdiğim örnekte, "yeni" yerine "geçersiz kılmak" olsaydı, o zaman b.Method () 'u çağırdığınızda; Türetilmiş sınıfın Yöntemi, Polimorfizm nedeniyle çağrılır.

Diğerlerinin açıkladığı gibi, mevcut bir yöntemi gizlemek için kullanılır. Üst sınıfta sanal olmayan bir yöntemi geçersiz kılmak için kullanışlıdır.

"Yeni" bir üye oluşturmanın polimorfik olmadığını unutmayın. Nesneyi temel türe çevirirseniz, türetilmiş türün üyesini kullanmaz.

Temel bir sınıfınız varsa:

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

Ve sonra türetilmiş sınıf:

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

}

Bir tür bildirir DerivedTypeve sonra onu DoSomething()çevirirseniz, yöntem polimorfik değildir, türetilmiş olanı değil, temel sınıfın yöntemini çağırır.

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

Dokümanlardan:

Türetilmiş sınıftaki yöntemin önünde new anahtar sözcüğü varsa, yöntem temel sınıftaki yöntemden bağımsız olarak tanımlanır.

Pratikte bunun anlamı:

Başka bir sınıftan miras alırsanız ve aynı imzayı paylaşan bir yönteminiz varsa, ana sınıftan bağımsız olması için onu 'yeni' olarak tanımlayabilirsiniz. Bu, eğer 'ebeveyn' sınıfa bir referansınız varsa, bu uygulamanın çalıştırılacağı, alt sınıfa bir referansınız varsa bu uygulamanın çalıştırılacağı anlamına gelir.

Kişisel olarak, normal olarak sınıf hiyerarşimi yanlış anladığım anlamına geldiği için 'yeni' anahtar kelimesini kullanmamaya çalışıyorum, ancak bazen yararlı olabileceği zamanlar oluyor. Bir yer, sürüm oluşturma ve geriye dönük uyumluluk içindir.

MSDN'de bunun için pek çok bilgi var .

Bu, yöntemin, temel sınıf tarafından miras alınan aynı ada sahip bir yöntemi değiştirdiği anlamına gelir. Sizin durumunuzda, muhtemelen temel sınıfta bu isimde bir yönteme sahip değilsiniz, yani yeni anahtar kelime tamamen gereksizdir.

Uzun lafın kısası - gerekli DEĞİLDİR, HİÇBİR davranışı değiştirmez ve okunabilirlik için PURELY oradadır.

Bu nedenle VS'de biraz dalgalı göreceksiniz, ancak kodunuz beklendiği gibi mükemmel bir şekilde derlenecek ve çalışacaktır.

newGeliştiricinin "Evet, temel bir yöntemi sakladığımı biliyorum, evet virtualveya overriden(polimorfizm) ile ilgili hiçbir şey yapmadığımı biliyorum, bunun anlamı anahtar kelimeyi oluşturmanın gerçekten değip değmeyeceğini merak etmek gerekir. Gerçekten sadece kendi yöntemini yaratmak istiyorum ".

Bu benim için biraz tuhaf ama belki de Javaarka plandan geldiğim için ve C#kalıtım ile kalıtım arasında şu temel fark var Java: İçinde Java, tarafından belirtilmedikçe yöntemler varsayılan olarak sanaldır final. İçinde C#, tarafından belirtilmedikçe yöntemler varsayılan olarak nihai / somuttur virtual.

Gönderen MSDN :

Temel sınıftan miras alınan bir üyeyi açıkça gizlemek için yeni değiştiriciyi kullanın. Devralınan bir üyeyi gizlemek için, aynı adı kullanarak türetilmiş sınıfta bildirin ve yeni değiştiriciyle değiştirin.

Bu şeye dikkat et.
Bir temel sınıfta uygulanan bir arabirimde tanımlanan bir yönteminiz var. Ardından, arabirimin yöntemini gizleyen türetilmiş bir sınıf oluşturursunuz, ancak türetilmiş sınıfı özellikle arabirimi uygularken bildirmezsiniz. Daha sonra yöntemi arabirime bir başvuru yoluyla çağırırsanız, temel sınıfın yöntemi çağrılır. Bununla birlikte, türetilmiş sınıfınız arabirimi özel olarak uygularsa, hangi başvuru türü kullanılırsa kullanılsın, yöntemi çağrılacaktır.

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

    }
}