nova palavra-chave na assinatura do método

Ao realizar uma refatoração, acabei criando um método como o exemplo abaixo. O tipo de dados foi alterado para simplificar.

Eu já tive uma declaração de atribuição como esta:

MyObject myVar = new MyObject();

Ele foi reformulado para isso por acidente:

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

Isso foi resultado de um erro de recortar / colar da minha parte, mas a newpalavra - chave em private static newé válida e compila.

Pergunta : O que a newpalavra - chave significa em uma assinatura de método? Presumo que seja algo introduzido no C # 3.0?

Como isso difere override?

Nova referência de palavra-chave do MSDN:

Referência MSDN

Aqui está um exemplo que encontrei na rede de um MVP da Microsoft que faz muito sentido: Link para o 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

A substituição só pode ser usada em casos muito específicos. Do MSDN:

Você não pode substituir um método não virtual ou estático. O método básico substituído deve ser virtual, abstrato ou substituir.

Portanto, a palavra-chave 'nova' é necessária para permitir que você 'substitua' métodos não virtuais e estáticos.

Não, na verdade não é "novo" (desculpe o trocadilho). É basicamente usado para "esconder" um método. IE:

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

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

Se você fizer isso:

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

O método na Base é o que será chamado, NÃO o da derivada.

Mais algumas informações: http://www.akadia.com/services/dotnet_polymorphism.html

Re sua edição: No exemplo que dei, se você "substituir" em vez de usar "novo", então, quando você chamar b.Method (); o Método da classe Derivada seria chamado por causa do polimorfismo.

Como outros explicaram, ele é usado para ocultar um método existente. É útil para substituir um método que não seja virtual na classe pai.

Lembre-se de que criar um "novo" membro não é polimórfico. Se você converter o objeto para o tipo base, ele não usará o membro do tipo derivado.

Se você tem uma classe base:

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

E então a classe derivada:

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

}

Se você declarar um tipo de DerivedTypee depois convertê-lo, o método DoSomething()não é polimórfico, ele chamará o método da classe base, não o derivado.

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

Dos documentos:

Se o método na classe derivada for precedido com a nova palavra-chave, o método será definido como independente do método na classe base.

O que isso significa na prática:

Se você herda de outra classe e tem um método que compartilha a mesma assinatura, você pode defini-lo como 'novo' para que seja independente da classe pai. Isso significa que se você tiver uma referência à classe 'pai', essa implementação será executada; se você tiver uma referência à classe filha, essa implementação será executada.

Pessoalmente, tento evitar a palavra-chave 'nova', pois normalmente significa que entendi errado minha hierarquia de classes, mas há momentos em que pode ser útil. Um lugar é para controle de versão e compatibilidade com versões anteriores.

Há muitas informações no MSDN para isso .

Isso significa que o método substitui um método com o mesmo nome herdado da classe base. No seu caso, você provavelmente não tem um método com esse nome na classe base, o que significa que a nova palavra-chave é totalmente supérflua.

Resumindo a história - NÃO é necessário, NÃO muda NENHUM comportamento e está PURAMENTE lá para facilitar a leitura.

É por isso que no VS você verá um pouco distorcido, mas seu código será compilado e executado perfeitamente e conforme o esperado.

É preciso perguntar se realmente valeu a pena criar a newpalavra - chave quando tudo o que ela significa é o reconhecimento do desenvolvedor "Sim, eu sei que estou escondendo um método básico, sim, eu sei que não estou fazendo nada relacionado a virtualou overriden(polimorfismo) - Eu realmente quero apenas criar seu próprio método ".

É um pouco bizarro para mim, mas talvez apenas porque venho de um Javabackground e há essa diferença fundamental entre C#herança e Java: Em Java, os métodos são virtuais por padrão, a menos que sejam especificados por final. Em C#, os métodos são finais / concretos por padrão, a menos que especificado por virtual.

Do MSDN :

Use o novo modificador para ocultar explicitamente um membro herdado de uma classe base. Para ocultar um membro herdado, declare-o na classe derivada usando o mesmo nome e modifique-o com o novo modificador.

Tenha cuidado com isso.
Você tem um método definido em uma interface que é implementada em uma classe base. Em seguida, você cria uma classe derivada que oculta o método da interface, mas não declara especificamente a classe derivada como implementando a interface. Se você chamar o método por meio de uma referência à interface, o método da classe base será chamado. No entanto, se sua classe derivada implementar especificamente a interface, seu método será chamado de qualquer tipo de referência usado.

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

    }
}