Différence entre les nouveaux et les remplacer

Remplacer le modificateur peut être utilisé sur
méthodes virtuelles et doit être utilisé sur
des méthodes abstraites. Cela indique pour
le compilateur d'utiliser la dernière défini
la mise en œuvre d'une méthode. Même si
la méthode est appelée sur une référence à
la classe de base, il va utiliser la
la mise en œuvre remplaçant.

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 qui remplace Base.DoIt.

Le nouveau modificateur indique le
le compilateur à utiliser implémentation de la classe de votre enfant
au lieu de la classe parent
la mise en œuvre. Tout code qui n'est pas
le référencement de votre classe, mais la mère
la classe va utiliser la classe parent
la mise en œuvre.

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

Sera d'abord appel Base.DoIt, puis Derived.DoIt. Ils sont en fait deux méthodes distinctes qui se trouvent avoir le même nom, plutôt que la dérivée de la méthode de substitution de la méthode de base.

Source: Microsoft blog

OriginalL'auteur rahul

Dans le premier cas, vous vous cachez la définition de la classe parent. Cela signifie qu'il ne sera invoquée lorsque vous traitez avec l'objet que l'enfant de la classe. Si vous lancez la classe de son type parent, le parent de la méthode sera invoquée. Dans le second cas, la méthode est substituée et sera invoqué indépendamment de savoir si l'objet est en fonte que l'enfant ou le parent de la classe.

OriginalL'auteur tvanfosson

Dans le cas 1, si vous avez utilisé l'appel DoIt() la méthode de la classe héritée alors que le type est déclaré comme étant de la classe de base vous permettra de voir l'action de la classe de base même.

/* 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();
}

OriginalL'auteur Matthew Whited

Ma façon de garder à l'esprit les mots-clés qu'ils sont à l'opposé les uns des autres.

override: virtual mot-clé doit être défini pour remplacer la méthode. La méthode à l'aide de override mot-clé que quel que soit le type de référence(référence de base de la classe ou de la classe dérivée) si il est instancié avec la classe de base, la méthode de classe de base s'exécute. Sinon, la méthode de la classe dérivée s'exécute.

new: si le mot clé est utilisé par une méthode, à la différence de override mot-clé, le type de référence est important. Si il est instancié avec la classe dérivée et le type de référence est la classe de base, la méthode de classe de base s'exécute. Si il est instancié avec la classe dérivée et le type de référence est dérivée de la classe, la méthode de la classe dérivée s'exécute. À savoir, c'est le contraste de override mot-clé. En passant, si vous oublier ou omettre d'ajouter un nouveau mot-clé de la méthode, le compilateur se comporte par défaut comme new mot-clé est utilisé.

class A 
{
    public string Foo() 
    {
        return "A";
    }

    public virtual string Test()
    {
        return "base test";
    }
}

class B: A
{
    public new string Foo() 
    {
        return "B";
    }
}

class C: B 
{
    public string Foo() 
    {
        return "C";
    }

    public override string Test() {
        return "derived test";
    }
}

Appel principal:

A AClass = new B();
Console.WriteLine(AClass.Foo());
B BClass = new B();
Console.WriteLine(BClass.Foo());
B BClassWithC = new C();
Console.WriteLine(BClassWithC.Foo());

Console.WriteLine(AClass.Test());
Console.WriteLine(BClassWithC.Test());

De sortie:

A
B
B
base test
derived test

Comme une note, je n'ai pas touché au C++ pour 3 ans et pourtant je crois que la façon dont je l'expliquer, c'est toujours utile pour vous.

OriginalL'auteur snr

L'article ci-dessous est en vb.net mais je pense que l'explication sur le nouveau vs remplace est très facile à saisir.

https://www.codeproject.com/articles/17477/the-dark-shadow-of-overrides

À un certain point dans l'article, il y a cette phrase:

En général, les Ombres assume la fonction associée avec le type est
invoquée, alors que les Remplacements suppose que l'objet de la mise en œuvre est
exécutée.

Accepté la réponse à cette question est parfait, mais je pense que cet article vous fournir de bons exemples pour ajouter le meilleur sens sur les différences entre ces deux mots-clés.

OriginalL'auteur Samuel

De la différence fonctionnelle ne sera pas montrer dans ces tests:

BaseClass bc = new BaseClass();

bc.DoIt();

DerivedClass dc = new DerivedClass();

dc.ShowIt();

Dans ce exmample, le Faire, qui est appelé est celui que vous attendre à être appelé.

Afin de voir la différence que vous avez à faire cela:

BaseClass obj = new DerivedClass();

obj.DoIt();

Vous de voir si vous exécutez le test que dans le cas 1 (que vous avez défini), la DoIt() dans BaseClass est appelé, dans le cas 2 (que vous avez défini), la DoIt() dans DerivedClass est appelé.

OriginalL'auteur Ken Falk

Dans le premier cas, il fera appel de la classe dérivée DoIt() méthode car le nouveau mot-clé masque de la classe de base DoIt() méthode.

Dans le deuxième cas, il s'appel bien sûr DoIt()

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

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

public class C : A
{
    public override void DoIt()
    {
        Console.WriteLine("C::DoIt()");
    }
}

laissez créer des instances de ces classes

   A instanceA = new A();

    B instanceB = new B();
    C instanceC = new C();

    instanceA.DoIt(); //A::DoIt()
    instanceB.DoIt(); //B::DoIt()
    instanceC.DoIt(); //B::DoIt()

Tout ce qui est prévu ci-dessus. Laissez instanceB et instanceC à instanceA et appel DoIt() la méthode et vérifier le résultat.

    instanceA = instanceB;
    instanceA.DoIt(); //A::DoIt() calls DoIt method in class A

    instanceA = instanceC;
    instanceA.DoIt();//C::DoIt() calls DoIt method in class C because it was overriden in class C

OriginalL'auteur cimey