Différence entre nouveau et dérogation

Question

Je me demande quelle est la différence entre les éléments suivants :

Cas 1 : Classe de base

public void DoIt();

Cas 1 : Classe héritée

public new void DoIt();

Cas 2 : Classe de base

public virtual void DoIt();

Cas 2 : Classe héritée

public override void DoIt();

Les cas 1 et 2 semblent avoir le même effet d'après les tests que j'ai effectués. Y a-t-il une différence ou une méthode préférée ?

Answer 1

La dérogation modifie et doit être utilisé pour les méthodes abstraites. Ceci indique pour la comp d'une méthode. Même si la méthode est appelée sur une référence à la classe de base, elle utilisera l'implémentation l'implémentation qui la remplace.

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

public class Derived : Base
{
    public override void DoIt()
    {
    }
}

Base b = new Derived();
b.DoIt();                      // Calls Derived.DoIt

appellera Derived.DoIt si cela l'emporte sur Base.DoIt .

Le nouveau modificateur indique au compilateur d'utiliser l'implémentation de votre classe enfant au lieu de l'implémentation de la classe mère de la classe mère. Tout code qui n'est pas référençant votre classe mais la classe utilisera l'implémentation de la classe parentale de la classe parente.

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

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

Base b = new Derived();
Derived d = new Derived();

b.DoIt();                      // Calls Base.DoIt
d.DoIt();                      // Calls Derived.DoIt

Premier appel Base.DoIt alors Derived.DoIt . Il s'agit en fait de deux méthodes entièrement distinctes qui portent le même nom, plutôt que d'une méthode dérivée qui surcharge la méthode de base.

Fuente: Blog de Microsoft

Answer 2

virtuel : indique qu'une méthode peut être remplacée par un héritier

surpasser La méthode virtuelle : remplace la fonctionnalité d'une méthode virtuelle dans une classe de base, en fournissant une fonctionnalité différente.

nouveau : cache la méthode originale (qui n'a pas besoin d'être virtuelle), offrant une fonctionnalité différente. Cette méthode ne doit être utilisée qu'en cas d'absolue nécessité.

Lorsque vous cachez une méthode, vous pouvez toujours accéder à la méthode d'origine en faisant appel à la classe de base. C'est utile dans certains cas, mais dangereux.

Answer 3

Dans le premier cas, vous cachez la définition dans la classe mère. Cela signifie qu'elle ne sera invoquée que lorsque vous traiterez l'objet en tant que classe enfant. Si la classe est convertie en son type parent, c'est la méthode du parent qui sera invoquée. Dans le second cas, la méthode est surchargée et sera invoquée indépendamment du fait que l'objet soit casté en tant que classe enfant ou parent.

Answer 4

Essayez ce qui suit : (cas1)

((BaseClass)(new InheritedClass())).DoIt()

Edit : virtual+override sont résolus au moment de l'exécution (donc override remplace réellement les méthodes virtuelles), alors que new crée simplement une nouvelle méthode avec le même nom, et cache l'ancienne, c'est résolu au moment de la compilation -> votre compilateur appellera la méthode qu'il "voit".

Answer 5

Dans le cas 1, si vous appelez la méthode DoIt() de la classe héritée alors que le type est déclaré comme classe de base, vous verrez l'action de la classe de base.

/* Results
Class1
Base1
Class2
Class2
*/
public abstract class Base1
{
    public void DoIt() { Console.WriteLine("Base1"); }
}
public  class Class1 : Base1 
{
    public new void DoIt() { Console.WriteLine("Class1"); }
}
public abstract class Base2
{
    public virtual void DoIt() { Console.WriteLine("Base2"); }
}
public class Class2 : Base2
{
    public override void DoIt() { Console.WriteLine("Class2"); }
}
static void Main(string[] args)
{
    var c1 = new Class1();
    c1.DoIt();
    ((Base1)c1).DoIt();

    var c2 = new Class2();
    c2.DoIt();
    ((Base2)c2).DoIt();
    Console.Read();
}