C# - Utilisation des mots-clés virtual+override vs. new

Question

Quelles sont les différences entre la déclaration d'une méthode dans un type de base " virtual "puis de le remplacer dans un type enfant en utilisant l'option " override "par opposition à la simple utilisation du mot clé " new "lors de la déclaration de la méthode correspondante dans le type enfant ?

Answer 1

Je trouve toujours ce genre de choses plus faciles à comprendre avec des images :

Encore une fois, en prenant le code de Joseph Daigle,

public class Foo
{
     public /*virtual*/ bool DoSomething() { return false; }
}

public class Bar : Foo
{
     public /*override or new*/ bool DoSomething() { return true; }
}

Si vous appelez ensuite le code comme ceci :

Foo a = new Bar();
a.DoSomething();

NOTE : L'important est que notre objet est en fait un Bar mais nous sommes en le stockant dans une variable de type Foo (ceci est similaire à la coulée)

Ensuite, le résultat sera le suivant, selon que vous avez utilisé virtual / override o new lors de la déclaration de vos classes.

Answer 2

Le mot clé "new" n'est pas une surcharge, il signifie une nouvelle méthode qui n'a rien à voir avec la méthode de la classe de base.

public class Foo
{
     public bool DoSomething() { return false; }
}

public class Bar : Foo
{
     public new bool DoSomething() { return true; }
}

public class Test
{
    public static void Main ()
    {
        Foo test = new Bar ();
        Console.WriteLine (test.DoSomething ());
    }
}

Cela imprime false, si vous aviez utilisé override cela aurait imprimé true.

(Code de base tiré de Joseph Daigle)

Donc, si vous faites du vrai polymorphisme, vous DOIT TOUJOURS PRÉVALOIR SUR . Le seul endroit où vous devez utiliser "new" est lorsque la méthode n'est liée en aucune façon à la version de la classe de base.

Answer 3

Voici un peu de code pour comprendre la différence de comportement entre les méthodes virtuelles et non virtuelles :

class A
{
    public void foo()
    {
        Console.WriteLine("A::foo()");
    }
    public virtual void bar()
    {
        Console.WriteLine("A::bar()");
    }
}

class B : A
{
    public new void foo()
    {
        Console.WriteLine("B::foo()");
    }
    public override void bar()
    {
        Console.WriteLine("B::bar()");
    }
}

class Program
{
    static int Main(string[] args)
    {
        B b = new B();
        A a = b;
        a.foo(); // Prints A::foo
        b.foo(); // Prints B::foo
        a.bar(); // Prints B::bar
        b.bar(); // Prints B::bar
        return 0;
    }
}

Answer 4

El new crée en fait un membre complètement nouveau qui n'existe que sur ce type spécifique.

Par exemple

public class Foo
{
     public bool DoSomething() { return false; }
}

public class Bar : Foo
{
     public new bool DoSomething() { return true; }
}

La méthode existe sur les deux types. Lorsque vous utilisez la réflexion et obtenez les membres du type Bar vous trouverez en fait 2 méthodes appelées DoSomething() qui sont exactement les mêmes. En utilisant new vous cachez effectivement l'implémentation dans la classe de base, de sorte que lorsque des classes dérivent de Bar (dans mon exemple) l'appel à la méthode base.DoSomething() va à Bar et non Foo .

Answer 5

virtuel / prioritaire indique au compilateur que les deux méthodes sont liées et que, dans certaines circonstances, lorsque vous pensez appeler la première méthode (virtuelle), il est en fait correct d'appeler la deuxième méthode (surchargée) à la place. C'est la base du polymorphisme.

(new SubClass() as BaseClass).VirtualFoo()

Appelle la méthode VirtualFoo() de la sous-classe.

nouveau indique au compilateur que vous ajoutez une méthode à une classe dérivée portant le même nom qu'une méthode de la classe de base, mais qu'elles n'ont aucune relation entre elles.

(new SubClass() as BaseClass).NewBar()

appellera la méthode NewBar() de la classe de base, tandis que :

(new SubClass()).NewBar()

Appelle la méthode NewBar() de la sous-classe.