Pourquoi utilisons-nous le virtuel et la remplacer?

Virtuel et remplacer sont à la base du mécanisme de l'héritage en programmation orientée objet.
C'est peut-être la chose la plus importante à comprendre lorsque vous utilisez des classes dans un langage comme C# ou Java.

http://en.wikipedia.org/wiki/Inheritance_(objet oriented_programming)

L'héritage permet de réutiliser le code de l'ajout de nouveaux champs, de propriétés et de méthodes ou de remplacer les méthodes et les propriétés de définir auparavant les classes.

Virtuel et Remplacer permet de remplacer le contenu d'une méthode, et quand je dis de remplacer, je te le remplacer.

Je voudrais vous proposer un bel exemple.

public class MyClassEnglish
{
    public virtual string SomethingToSay()
    {
        return "Hello!";
    }

    public void WriteToConsole()
    {
        Console.WriteLine(this.SomethingToSay());
    }
}

public class MyClassItalian :
    MyClassEnglish
{
    public override string SomethingToSay()
    {
        return "Ciao!";
    }
}

int main()
{
    MyClassItalian it = new MyClassItalian();

    it.WriteToConsole();
}

Si vous omettez le virtuel et la remplacer, MyClassItalian affichera "Bonjour!" et pas "Ciao!".

Dans votre exemple vous afficher un Ombrage de la technique, mais le compilateur devrait vous donner un avertissement.
Vous shoul ajouter le "nouveau" mot clé si vous souhaitez masquer une méthode dans une classe de base.
Le masquage d'une méthode n'est pas primordial! Est juste de se cacher.

Une utilisation possible qui vient à l'esprit est qu'il peut être utilisé lorsque vous avez besoin d'un certain type d'optimisation, par exemple.

public abstract class MySpecialListBase
{
    public int Count()
    {
        return this.GetCount();
    }

    protected abstract int GetCount();
}

public sealed class MySpecialArrayList : MySpecialListBase
{
    int count;

    public new int Count()
    {
        return this.count;
    }

    protected override int GetCount()
    {
        return this.count;
    }
}

Maintenant...
Vous pouvez utiliser MySpecialListBase dans tout votre code, et lorsque vous appelez la fonction Count() il va appeler la méthode virtuelle GetCount().
Mais si vous utilisez seulement MySpecialArrayList il va appeler l'optimisation de la fonction Count() qui n'est pas du virtuel et que le juste retour d'un champ, l'augmentation des performances.

//This works with all kind of lists, but since it is a more general purpose method it will call the virtual method.    
public void MyMethod(MySpecialListBase list)
{
    Console.WriteLine(list.Count());
}

//This works only with MySpecialArrayList, and will use the optimized method.
public void MyMethod(MySpecialArrayList list)
{
    Console.WriteLine(list.Count());
}

OriginalL'auteur Salvatore Previti

La Redéfinition De Méthode:

Où vous définir ou mettre en œuvre une méthode virtuelle dans une classe parente, puis de la remplacer dans une classe descendante.

Lorsque vous décidez de déclarer une méthode virtuelle, vous donnant la permission de classes dérivées pour étendre et redéfinir la méthode avec leur propre mise en œuvre. Vous pouvez avoir la prolongation de l'appel de la méthode la méthode parent du code de trop.

Dans la plupart des langages à objets, vous pouvez également choisir de masquer une méthode parent. Lorsque vous introduisez une nouvelle mise en œuvre du même nom de méthode avec la même signature sans écraser, vous vous cachez de la méthode parent.

C# Primordial
En C#, vous pouvez spécifier une méthode virtuelle avec le mot clé virtual dans une classe parente, et d'étendre (ou remplacer) dans un descendant de la classe en utilisant le mot-clé override.

Utiliser le mot clé base en descendant méthode à exécuter le code dans la méthode parent, c'est à dire de la base.SomeMethod().

Exemple De Syntaxe:

class Robot
{
  public virtual void Speak()
  {
  }
}

class Cyborg:Robot
{
   public override void Speak()
   {
   }
}

Remplacer Détails
Vous ne pouvez pas remplacer une non-méthode virtuelle, ni une méthode statique.
La première version de la méthode parent doit être virtuelle ou abstraite.
Vous pouvez remplacer n'importe quel parent méthode marqué virtuel, abstrait, ou de la remplacer (déjà remplacé).
Les méthodes doivent avoir la même signature.
Les méthodes doivent avoir la même visibilité (le même niveau d'accès).
Utilisez le mot clé base de référence à la classe parent comme dans la base.SomeMethod().
C# Override Exemple
L'extrait de code suivant illustre l'utilisation de virtuel et de remplacer de remplacer un parent méthode dans une classe descendante.

using System;

class Dog
{
   public virtual void Bark()
   {
       Console.WriteLine("RUFF!");
   }
}

class GermanShepard:Dog
{
    public override void Bark()
    {
       Console.WriteLine("Rrrrooouuff!!");
    }
}

class Chiuaua:Dog
{
    public override void Bark()
    {
         Console.WriteLine("ruff");
    }
}
class InclusionExample
{
     public static void Main()
     {
        Dog MyDog=new Dog();    
        MyDog=new GermanShepard();
        MyDog.Bark(); //prints Rrrrooouuff!!

        MyDog=new Chiuaua();
        MyDog.Bark(); //prints ruff;
    }
}

Cacher une Méthode avec de Nouveaux
Utiliser le mot clé new pour introduire une nouvelle mise en œuvre d'une méthode parent (ce qui permet de masquer la méthode parent). Vous pouvez masquer une méthode sans utiliser de nouveau, mais vous obtiendrez un avertissement du compilateur. À l'aide de nouveau va supprimer l'avertissement.

La nouvelle et remplacer les modificateurs ont des significations différentes. Le nouveau modificateur crée un nouveau membre avec le même nom, la signature et à la visibilité et cache le membre d'origine. Remplacer le modificateur s'étend de la mise en œuvre d'un membre hérité et permet de mettre en oeuvre l'héritage-polymorphisme basé sur l'.

Éviter d'Introduire de Nouveaux Membres: Parfois il y a des raisons claires pour introduire une nouvelle méthode avec le même nom, la signature et la visibilité d'une méthode parent. Dans les cas clairs, l'introduction d'un nouveau membre est une fonction puissante. Toutefois, si vous n'avez pas de raison claire, puis éviter d'introduire une nouvelle version de la méthode est le nom de la nouvelle méthode de quelque chose d'unique et approprié.

class Robot : System.Object
{
  public void Speak()
  {
    MessageBox.Show("Robot says hi");
  }
}

class Cyborg : Robot
{
  new public void Speak()
  {
    MessageBox.Show("hi");
  }
}

L'appel de la Classe de Base de la Version
Une tâche commune À la OO est d'étendre une méthode par la première exécution de la méthode parent code, puis l'ajout de code. Utilisez le mot clé base de référence à la classe parent comme dans la base.SomeMethod().

class Robot : System.Object
{
    public virtual void Speak()
    {
       MessageBox.Show("Robot says hi");
    }
}
class Cyborg : Robot
{
  public override void Speak()
  {
      base.Speak(); 
      MessageBox.Show("hi");
  }
}

OriginalL'auteur Enigma State