nouveau mot-clé dans la signature de la méthode

Non, ce n'est pas vraiment "nouveau" (pardonnez le calembour). Il est essentiellement utilisé pour "cacher" une méthode. C'est à dire:

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

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

Ensuite, si vous faites cela:

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

La méthode de Base est celui qui sera appelé, PAS celui de la dérivée.

Quelques infos: http://www.akadia.com/services/dotnet_polymorphism.html

Re votre edit: Dans l'exemple que j'ai donné, si vous étiez à "substituer" au lieu d'utiliser "nouveau" puis quand vous appelez.b.Méthode(); la classe Dérivée de la Méthode doit être appelée en raison du Polymorphisme.

De la documentation:

Si la méthode dans la classe dérivée est précédé du mot-clé new, la méthode est définie comme étant indépendants de la méthode dans la classe de base.

Ce que cela signifie dans la pratique:

Si vous hériter d'une autre classe et que vous avez une méthode qui partage la même signature que vous pouvez le définir comme "nouveau", de sorte qu'il est indépendant de la classe parent. Cela signifie que si vous avez une référence pour le "parent" de la classe alors que la mise en œuvre sera exécutée, si vous avez une référence à la classe enfant alors que la mise en œuvre sera exécutée.

Personnellement, j'essaie d'éviter le "nouveau" mot-clé signifie normalement j'ai ma hiérarchie de classe mal, mais il y a des moments où il peut être utile. Une place est pour la gestion des versions et compatibilité descendante.

Il y a beaucoup d'informations dans la MSDN pour cette.

Longue histoire courte -- il n'est PAS nécessaire, il change PAS de comportement, et c'est uniquement là pour des raisons de lisibilité.

C'est pourquoi VS, vous verrez un peu ondulés, mais votre code de compiler et d'exécuter parfaitement bien et comme prévu.

Est de se demander si ça valait vraiment la création de la new mot-clé quand tout cela signifie, c'est que le développeur en reconnaissant "Oui, je sais que je me cache une méthode de base, oui, je sais que je ne vais pas faire tout ce qui est lié à virtual ou overriden (polymorphisme) -- j'ai vraiment envie de créer sa propre méthode".

C'est un peu bizarre pour moi, mais peut-être seulement parce que je viens d'un Java de fond et il y a cette différence fondamentale entre C# héritage et Java: Dans Java, les méthodes sont virtuelles par défaut, sauf si spécifié par final. Dans C#, les méthodes sont final/béton par défaut, sauf si spécifié par virtual.

Attention à ce piège.

Vous avez une méthode définie dans une interface qui est mis en œuvre dans une classe de base. Ensuite, vous créez une classe dérivée qui cache l'interface de la méthode, mais ne pas déclarer expressément la classe dérivée comme la mise en œuvre de l'interface. Si vous appelez la méthode via une référence à l'interface de la classe de base, la méthode sera appelée.
Toutefois, si votre classe dérivée n'est précisément de mettre en œuvre l'interface, puis sa méthode sera appelée quel que soit le type de référence est utilisée.

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

    }
}