C# Covariance et Contravariance

La covariance et la contravariance nous rendent plus flexibles lors de la gestion de la hiérarchie des classes.

Avant de comprendre la covariance et la contravariance, regardez la hiérarchie de classes suivante :

public class Small
{　
}
public class Big: Small
{
}
public class Bigger : Big
{　
　　　　
}

Selon l'exemple de classe précédent, Small est la classe de base de Big, et Big est la classe de base de Bigger. Un point à retenir ici est que la classe dérivée aura toujours plus que la classe de base, donc la classe de base est plus petite que la classe dérivée.

Maintenant, regardez l'initialisation suivante :

Comme indiqué précédemment, la classe de base peut contenir la classe dérivée, mais la classe dérivée ne peut pas contenir la classe de base. En d'autres termes, un exemple même si la demande est petite peut accepter grand, mais si la demande est grande, il ne peut pas accepter petit.

Maintenant, permettons-nous de comprendre la covariance et la contravariance.

C# Covariance (Covariance)

La covariance vous permet de transmettre des types dérivés, où le type de base est nécessaire. La covariance est comme la variance de même type. La classe de base et les classes dérivées sont considérées comme des classes de même type qui ajoutent des fonctionnalités supplémentaires au type de base. Par conséquent, la covariance vous permet d'utiliser des classes dérivées à la place de la classe de base où il est nécessaire de la classe de base (si nécessaire de la sous-classe, la règle : il peut accepter la grande classe).

La covariance peut être appliquée aux délégués, aux génériques, aux tableaux, aux interfaces, etc.

Covariance des délégués

La covariance dans les délégués permet une flexibilité dans le type de retour des méthodes du délégué.

public delegate Small covarDel(Big mc);
public class Program
{
　　　　public static Big Method1(Big bg)
　　　　{
　　　　　　　　Console.WriteLine("Method1");
　　　　
　　　　　　　　return new Big();
　　　　}
　　　　public static Small Method2(Big bg)
　　　　{
　　　　　　　　Console.WriteLine("Method2");
　　　　
　　　　　　　　return new Small();
　　　　}
　　　　　　　　
　　　　public static void Main(string[] args)
　　　　{
　　　　　　　　covarDel del = Method1;
　　　　　　　　Small sm1　= del(new Big());
　　　　　　　　del = Method2;
　　　　　　　　Small sm2　= del(new Big());
　　　　}
}

Méthode1
Méthode2

Comme vous pouvez le voir dans l'exemple ci-dessus, la délégation attend un type de retour Small (classe mère), mais nous pouvons toujours assigner un Method1et un Method2.

Par conséquent, la covarience vous permet d'affecter une méthode à une délégation qui a un type de retour de classe fille plus pauvre.

Contravariance (contravarience) en C#

Appliquer Contravariance (contravarience) aux paramètres. La contravariance permet d'affecter un paramètre de type classe mère à une méthode de délégation qui attend un paramètre de type classe fille.

Continuons l'exemple précédent en ajoutant un Method3:

delegate Small covarDel(Big mc);
class Program
{
　　　　static Big Method1(Big bg)
　　　　{
　　　　　　　　Console.WriteLine("Method1");
　　　　　　　　return new Big();
　　　　}
　　　　static Small Method2(Big bg)
　　　　{
　　　　　　　　Console.WriteLine("Method2");
　　　　　　　　return new Small();
　　　　}
　　　　static Small Method3(Small sml)
　　　　{
　　　　　　　　Console.WriteLine("Method3");
　　　　　　　　
　　　　　　　　return new Small();
　　　　}
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　covarDel del = Method1;
　　　　　　　　del　+= Method2;
　　　　　　　　del　+= Method3;
　　　　　　　　Small sm = del(new Big());
}

Méthode1
Méthode2
Méthode3

Comme vous le voyez, Method3Avec un paramètre de type Small, tandis que la délégation attend un paramètre de type Big. Cependant, vous pouvez assigner Method3Utilisé avec une délégation.

Vous pouvez également utiliser covarience et contravarience de la même manière que montrée ci-dessous.

delegate Small covarDel(Big mc); class Program
{
	static Big Method4(Small sml)
　　　　{
	Console.WriteLine("Method3");　　　　
　　　　　　　　return new Big();
　　　　}
	static void Main(string[] args)
　　　　{
	covarDel del = Method4;　　　　
　　　　　　　　Small sm = del(new Big());
　　　　}
}

Méthode4