Comment la covariance et la contravariance améliorent-elles la flexibilité et la réutilisabilité du code ?

Covariance et contravariance : applications pratiques

La mise en œuvre de la covariance et de la contravariance dans des scénarios réels peut améliorer la flexibilité et la réutilisabilité du code. Voici un exemple simplifié :

Covariante :

Les interfaces covariantes définissent des paramètres de sortie qui permettent l'affectation de types dérivés à des types moins dérivés. Par exemple :

<code class="language-c#">public interface ICovariant<out T> { }
public class Covariant<T> : ICovariant<T> { }
public class Fruit { }
public class Apple : Fruit { }</code>

Ici, ICovariant<Fruit> peut être attribué à ICovariant<Apple> car Apple est un sous-type de Fruit. Covariance nous permet de stocker différents types de données sans conversion, ce qui rend le code plus concis et polyvalent.

IContravariant :

L'interface Contravariant définit les paramètres d'entrée, permettant l'affectation de types moins dérivés à des types plus dérivés. Par exemple :

<code class="language-c#">public interface IContravariant<in T> { }
public class Contravariant<T> : IContravariant<T> { }</code>

IContravariant<Apple> peut être attribué à IContravariant<Fruit> car Fruit est un supertype de pomme. Contravariance permet d'accepter différents types de paramètres d'entrée tout en garantissant un comportement cohérent.

Exemple :

Le code suivant démontre l'utilisation de la covariance et de la contravariance :

<code class="language-c#">public class TheInsAndOuts
{
    public void Covariance()
    {
        ICovariant<Fruit> fruit = new Covariant<Fruit>();
        ICovariant<Apple> apple = new Covariant<Apple>();

        Covariance(fruit);
        Covariance(apple); // 通过协变允许从 Apple 向 Fruit 上转型
    }

    public void Contravariance()
    {
        IContravariant<Fruit> fruit = new Contravariant<Fruit>();
        IContravariant<Apple> apple = new Contravariant<Apple>();

        Contravariant(fruit); // 通过逆变允许从 Fruit 向 Apple 下转型
        Contravariant(apple);
    }

    public void Covariant(ICovariant<Fruit> fruit) { }

    public void Contravariant(IContravariant<Apple> apple) { }
}</code>

Résumé :

La covariance et la contravariance permettent aux développeurs de créer du code flexible et réutilisable en autorisant des affectations de types compatibles. Ils étendent les fonctionnalités d'héritage et facilitent le traitement des données et le passage de paramètres entre objets de différents types.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!