nueva palabra clave en la firma del método

No, en realidad no es "nuevo" (perdón por el juego de palabras). Se utiliza básicamente para "ocultar" un método. IE:

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

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

Si luego haces esto:

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

El método en la Base es el que será llamado, NO el que está en el derivado.

Algo más de información: http://www.akadia.com/services/dotnet_polymorphism.html

Re your edit: En el ejemplo que di, si fueras a " override "en lugar de usar" new " entonces cuando llames a b.Method (); la clase derivada Método sería llamado debido al polimorfismo.

Como otros explicaron, se usa para ocultar un método existente. Es útil para sobreescribir un método que no es virtual en la clase padre.

Tenga en cuenta que crear un miembro "nuevo" no es polimórfico. Si envía el objeto al tipo base, no utilizará el miembro del tipo derivado.

Si tienes una clase base:

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

Y luego la clase derivada:

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

}

Si declaras un tipo de DerivedType y luego lo lanzas, el método DoSomething() no es polimórfico, lo hará llame al método de la clase base, no al derivado.

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

De los documentos:

Si el método en la clase derivada está precedido por la palabra clave new, el método se define como independiente del método en la clase base.

Lo que esto significa en la práctica:

Si hereda de otra clase y tiene un método que comparte la misma firma, puede definirlo como 'nuevo' para que sea independiente de la clase padre. Esto significa que si usted tiene una referencia a la clase' padre ' entonces esa implementación será ejecutada, si usted tiene una referencia a la clase hija entonces esa implementación será ejecutada.

Personalmente trato de evitar la palabra clave 'new', ya que normalmente significa que tengo mi jerarquía de clases equivocada, pero hay momentos en que puede ser útil. Un lugar es para el control de versiones y la compatibilidad con versiones anteriores.

Hay mucha información en el MSDN para esto.

Significa que el método reemplaza un método con el mismo nombre heredado por la clase base. En tu caso, probablemente no tengas un método con ese nombre en la clase base, lo que significa que la nueva palabra clave es totalmente superflua.

En pocas palabras NOT no es necesario, no cambia el comportamiento, y es PURAMENTE allí para la legibilidad.

Es por eso que en VS verá un poco torcido, sin embargo, su código se compilará y se ejecutará perfectamente bien y como se espera.

Uno tiene que preguntarse si realmente valió la pena crear la palabra clave new cuando todo lo que significa es que el desarrollador reconoce " Sí, sé que estoy ocultando un método base, sí sé que no estoy haciendo nada relacionado con virtual o overriden (polimorfismo) -- Realmente quiero crear su propio método".

Es un poco extraño para mí, pero tal vez solo porque vengo de un fondo Java y hay esta diferencia fundamental entre C# herencia y Java: En Java, los métodos son virtuales por defecto a menos que se especifique por final. En C#, los métodos son finales/concretos por defecto a menos que se especifique por virtual.

De MSDN :

Utilice el nuevo modificador para ocultar explícitamente un miembro heredado de un clase base. Para ocultar un miembro heredado, declararlo en el derivado clase usando el mismo nombre, y modifíquelo con el nuevo modificador.

Ten cuidado con esto.
Tiene un método definido en una interfaz que se implementa en una clase base. A continuación, crea una clase derivada que oculta el método de la interfaz, pero no declara específicamente que la clase derivada implemente la interfaz. Si luego llama al método a través de una referencia a la interfaz, se llamará al método de la clase base. Sin embargo, si su clase derivada implementa específicamente la interfaz, entonces su método se llamará cualquiera que sea el tipo de se utiliza la referencia.

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

    }
}