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

Lors d'un refactoring, j'ai fini par créer une méthode comme l'exemple ci-dessous. Le type de données a été modifié par souci de simplicité.

J'avais auparavant une déclaration de mission comme celle-ci:

MyObject myVar = new MyObject();

Il a été remanié à ceci par accident:

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

C'était le résultat d'une erreur de copier / coller de ma part, mais le newmot clé in private static newest valide et compile.

Question : Que signifie le newmot - clé dans une signature de méthode? Je suppose que c'est quelque chose d'introduit dans C # 3.0?

En quoi cela diffère- overridet-il?

Nouvelle référence de mot clé de MSDN:

Référence MSDN

Voici un exemple que j'ai trouvé sur le net d'un MVP Microsoft qui avait du bon sens: Lien vers l'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

Le remplacement ne peut être utilisé que dans des cas très spécifiques. Depuis MSDN:

Vous ne pouvez pas remplacer une méthode non virtuelle ou statique. La méthode de base remplacée doit être virtuelle, abstraite ou remplacée.

Le mot-clé «nouveau» est donc nécessaire pour vous permettre de «remplacer» les méthodes non virtuelles et statiques.

Non, ce n'est en fait pas «nouveau» (pardonnez le jeu de mots). 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(){}
}

Si vous faites ensuite ceci:

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

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

Quelques informations supplémentaires: http://www.akadia.com/services/dotnet_polymorphism.html

Re votre modification: Dans l'exemple que j'ai donné, si vous deviez "remplacer" au lieu d'utiliser "new" alors quand vous appelez b.Method (); la méthode de la classe dérivée serait appelée à cause du polymorphisme.

Comme d'autres l'ont expliqué, il est utilisé pour masquer une méthode existante. C'est utile pour remplacer une méthode qui n'est pas virtuelle dans la classe parent.

Gardez à l'esprit que la création d'un "nouveau" membre n'est pas polymorphe. Si vous transtypez l'objet vers le type de base, il n'utilisera pas le membre du type dérivé.

Si vous avez une classe de base:

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

Et puis la classe dérivée:

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

}

Si vous déclarez un type de DerivedTypeet que vous le castez, la méthode DoSomething()n'est pas polymorphe, elle appellera la méthode de la classe de base, pas celle dérivée.

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

À partir de la documentation:

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

Ce que cela signifie en pratique:

Si vous héritez d'une autre classe et que vous avez une méthode qui partage la même signature, vous pouvez la définir comme «nouvelle» afin qu'elle soit indépendante de la classe parente. Cela signifie que si vous avez une référence à la classe «parent», cette implémentation sera exécutée, si vous avez une référence à la classe enfant, cette implémentation sera exécutée.

Personnellement, j'essaie d'éviter le mot-clé «nouveau» car cela signifie normalement que ma hiérarchie de classes est erronée, mais il y a des moments où cela peut être utile. Un endroit est pour la gestion des versions et la compatibilité ascendante.

Il y a beaucoup d'informations dans le MSDN pour cela .

Cela signifie que la méthode remplace une méthode par le même nom hérité par la classe de base. Dans votre cas, vous n'avez probablement pas de méthode portant ce nom dans la classe de base, ce qui signifie que le nouveau mot-clé est totalement superflu.

Pour faire court - ce n'est PAS nécessaire, cela ne change AUCUN comportement et il est PUREMENT là pour la lisibilité.

C'est pourquoi dans VS, vous verrez un peu ondulé, mais votre code se compilera et fonctionnera parfaitement bien et comme prévu.

Il faut se demander si cela valait vraiment la peine de créer le newmot - clé alors que tout cela signifie que le développeur reconnaît: "Oui, je sais que je cache une méthode de base, oui je sais que je ne fais rien en rapport avec virtualou overriden(polymorphisme) - Je veux vraiment créer sa propre méthode ».

C'est un peu bizarre pour moi, mais peut-être seulement parce que je viens d'un Javaarrière-plan et qu'il y a cette différence fondamentale entre l' 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 finales / concrètes par défaut, sauf si spécifié par virtual.

Depuis MSDN :

Utilisez le nouveau modificateur pour masquer explicitement un membre hérité d'une classe de base. Pour masquer un membre hérité, déclarez-le dans la classe dérivée en utilisant le même nom et modifiez-le avec le nouveau modificateur.

Faites attention à ce piège.
Vous avez une méthode définie dans une interface qui est implémentée dans une classe de base. Vous créez ensuite une classe dérivée qui masque la méthode de l'interface, mais ne déclarez pas spécifiquement la classe dérivée comme implémentant l'interface. Si vous appelez ensuite la méthode via une référence à l'interface, la méthode de la classe de base sera appelée. Cependant, si votre classe dérivée implémente spécifiquement l'interface, sa méthode sera appelée quel que soit le type de référence utilisé.

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

    }
}