Pourquoi et quand utiliser le polymorphisme?

Polymorphisme vient vraiment pratique lorsque vous voulez avoir quelque chose comme une méthode générale qui ne se soucie pas de la mise en œuvre spécifique, mais seulement sur le principal type. À l'aide de vos animaux exemple:

public static void Main()
{
    var animals = new List<Animal>();
    animals.Add(new Dog());
    animals.Add(new Cat());

    foreach (var animal in animals)
        Feed(animal);
}

public static void Feed(Animal animal)
{
    animal.Eat();
}

Noter que la méthode ne se soucie pas de ce genre d'animal qu'il obtient, il va juste essayer de l'alimenter. Peut-être Dog implémente Eat() tel qu'il engloutit tout ce qui bouge. Peut-être Cat() la met en œuvre, telle qu'elle prend une bouchée et s'éloigne. Peut-être Fish() la met en œuvre, telle qu'elle mange trop et meurt. La méthode elle-même ne se soucie pas de qui Animal il obtient, et vous pouvez facilement ajouter plus de Animal types sans avoir à changer de méthode qui les accepte.

(Liée à cette est la Modèle De Stratégie.)

À l'inverse, parfois, vous voulez une méthode retourne un type général, indépendamment de ce qui est mis en œuvre. Un exemple courant que j'utilise est ceci:

public interface AnimalRepository
{
    IEnumerable<Animal> GetAnimals();
}

Il utilise le polymorphisme de deux manières, en fait. Tout d'abord, l'énumération de Animals qu'il renvoie peut être de tout type. Dans ce cas, le code appelant se soucient pas qui est qui, ça va de les utiliser d'une manière plus générale (comme dans l'exemple précédent). En outre, tout ce qui implémente IEnumerable peuvent être retournés.

Ainsi, par exemple, j'ai une implémentation de cette interface qui utilise LINQ to SQL:

public class AnimalRepositoryImplementation : AnimalRepository
{
    public IEnumerable<Animal> GetAnimals()
    {
        return new DBContext().Animals;
    }
}

Il renvoie un IQueryable. Quel que soit les appels de la méthode, cependant, ne se soucie pas que c'est un IQueryable. Il va seulement pour utiliser les fonctionnalités IEnumerable.

Ou, j'ai une autre mise en œuvre de maquette de test:

public class AnimalRepositoryImplementation : AnimalRepository
{
    private IList<Animal> animals = new List<Animal>();

    public IEnumerable<Animal> GetAnimals()
    {
        return animals;
    }
}

C'est au retour d'une IList, qui est de nouveau transformé en la plus générale IEnumerable parce que c'est tout le code d'appel va utiliser.

Ces sont aussi appelés la covariance et la contravariance. Dans le cas de retour d'un IEnumerable ci-dessus, les types déplacé de plus spécifique (IQueryable et IList) pour plus générique (IEnumerable). Ils ont été en mesure de le faire sans conversion, car plus spécifiques type est aussi une instance d'un plus type générique dans la hiérarchie des types.

Également liée à cela est le Principe De Substitution De Liskov, qui stipule que toute sous-type d'un type peut être utilisé en tant que parent de type sans nécessiter des modifications au programme. C'est, si Dog est un sous-type de Animal alors vous devriez toujours être en mesure d'utiliser un Dog comme un Animal sans avoir à savoir que c'est un Dog ou que les considérations spéciales pour cela.

Vous pouvez également bénéficier de la recherche dans les Inversion De Dépendance Principe, le ci-dessus référentiel de mise en œuvre qui peut servir d'exemple. L'application en cours d'exécution n'est pas concerné par le type (AnimalRepositoryImplementation) implémente l'interface. Le seul type il se soucie est l'interface elle-même. La mise en œuvre de types peuvent avoir d'autres publics ou, au moins, les méthodes internes dont la mise en œuvre des assemblages utilisation concernant la façon dont cette dépendance est mis en œuvre, mais qui ne sont d'aucune conséquence pour les consommateurs de code. Chaque mise en œuvre peuvent être changées à volonté et code d'appel ne doivent être fournis avec n'importe quelle instance de la plus générique de l'interface.

---

Note de côté: personnellement, je trouve que l'héritage est souvent galvaudé, en particulier la plaine de l'héritage comme dans le Animal exemple où Animal lui-même ne devrait pas être un instantiatable classe. Il peut être une interface ou une classe abstraite, peut-être, si la forme générique est nécessaire pour la logique de l'application. Mais ne le faites pas juste pour le plaisir de le faire.

En général, préfèrent la composition au cours de l'héritage comme recommandé par le Gang Of four. (Si vous ne disposez pas d'une copie, d'en obtenir un.) N'abusez pas de l'héritage, mais ne l'utiliser le cas échéant. Peut-être que l'application aurait plus de sens si commun Animal les fonctionnalités ont été regroupés en composants et chaque Animal a été construit de ces composants? Le plus couramment utilisé Car exemple, peut prendre une leçon de tout ça, pour sûr.

Garder vos types de logique défini. Vous devriez être en mesure d'écrire new Animal()? Est-il judicieux d'avoir un générique instance de Animal c'est pas plus précis? Certainement pas. Mais il peut faire sens pour avoir une fonctionnalité générique qui doit être capable de fonctionner sur n'importe quel Animal (alimenter, se reproduire, mourir, etc.).

OriginalL'auteur David

Parce que vous devriez garder la commune de comportement dans votre classe de base et de redéfinir les comportements qui sont différentes pour une sous-classe spécifique. Ainsi, vous réduisez la duplication de code.

Vous pouvez toujours instancier votre objet comme Chien chien = new Chien() dans votre exemple. Qui a peu à voir avec le polymorphisme. Mais il est préférable d'utiliser la classe de base lorsque vous essayez de passer à une méthode qui attend un animal, un homme, le chien, etc.

OriginalL'auteur AD.Net

Cela est très pratique lorsque vous avez plusieurs classes héritant de la même classe parent ou de la mise en œuvre de la même interface. Par exemple:

class Cat : Animal {
    public override void eat()
    {
        Console.Write("Cat eating");
    }
}

class Program {

    public void Main() {
        Animal cat = new Cat();
        Animal dog = new Dog();

        cat.eat();
        dog.eat();
    }
}

Ce sera de sortie:

"Cat eating"
"Dog eating"

OriginalL'auteur Simon Germain