Covariance et contravariance (C#)

En C#, la covariance et la contravariance activent la conversion de référence implicite pour les types de tableaux, les types délégués et les arguments de type générique. La covariance conserve la compatibilité des affectations et la contravariance l’inverse.

Le code suivant illustre la différence entre la compatibilité des affectations, la covariance et la contravariance.

// Assignment compatibility.
string str = "test";  
// An object of a more derived type is assigned to an object of a less derived type.
object obj = str;  
  
// Covariance.
IEnumerable<string> strings = new List<string>();  
// An object that is instantiated with a more derived type argument
// is assigned to an object instantiated with a less derived type argument.
// Assignment compatibility is preserved.
IEnumerable<object> objects = strings;  
  
// Contravariance.
// Assume that the following method is in the class:
static void SetObject(object o) { }
Action<object> actObject = SetObject;  
// An object that is instantiated with a less derived type argument
// is assigned to an object instantiated with a more derived type argument.
// Assignment compatibility is reversed.
Action<string> actString = actObject;  

La covariance pour les tableaux permet la conversion implicite d’un tableau d’un type plus dérivé en tableau d’un type moins dérivé. Toutefois, cette opération n’est pas de type sécurisé, comme illustré dans l’exemple de code suivant.

object[] array = new String[10];  
// The following statement produces a run-time exception.  
// array[0] = 10;  

La prise en charge de la covariance et de la contravariance pour les groupes de méthodes permet de faire correspondre les signatures de méthode avec les types délégués. Cela vous permet d’affecter à des délégués non seulement des méthodes qui ont des signatures correspondantes, mais également des méthodes qui retournent des types dérivés (covariance) ou qui acceptent des paramètres qui ont moins de types dérivés (contravariance) que ceux spécifiés par le type délégué. Pour plus d’informations, consultez Variance dans les délégués (C#) et Utilisation de la variance dans les délégués (C#).

L’exemple de code suivant montre la prise en charge de la covariance et de la contravariance pour les groupes de méthodes.

static object GetObject() { return null; }  
static void SetObject(object obj) { }  
  
static string GetString() { return ""; }  
static void SetString(string str) { }  
  
static void Test()  
{  
    // Covariance. A delegate specifies a return type as object,  
    // but you can assign a method that returns a string.  
    Func<object> del = GetString;  
  
    // Contravariance. A delegate specifies a parameter type as string,  
    // but you can assign a method that takes an object.  
    Action<string> del2 = SetObject;  
}  

Dans .NET Framework 4 et versions ultérieures, C# prend en charge la covariance et la contravariance dans les interfaces génériques et les délégués et permet la conversion implicite des paramètres de type générique. Pour plus d’informations, consultez Variance dans les interfaces génériques (C#) et Variance dans les délégués (C#).

L’exemple de code suivant montre la conversion de référence implicite pour les interfaces génériques.

IEnumerable<String> strings = new List<String>();  
IEnumerable<Object> objects = strings;  

Une interface ou un délégué générique est appelé variant si ses paramètres génériques sont déclarés covariants ou contravariants. C# vous permet de créer vos propres interfaces et délégués variants. Pour plus d’informations, consultez Création d’interfaces génériques variant (C#) et Variance dans les délégués (C#).

Rubriques connexes

Titre	Descriptif
Variance dans les interfaces génériques (C#)	Présente la covariance et la contravariance dans les interfaces génériques et fournit une liste des interfaces génériques variant en .NET.
Création d’interfaces génériques variant (C#)	Montre comment créer des interfaces variant personnalisées.
Utilisation de variance dans les interfaces pour les collections génériques (C#)	Montre comment la prise en charge de la covariance et de la contravariance dans les IEnumerable<T>IComparable<T> interfaces peut vous aider à réutiliser le code.
Variance dans les délégués (C#)	Présente la covariance et la contravariance dans les délégués génériques et non génériques, et fournit une liste des délégués génériques de type variant dans .NET.
Utilisation de la variance dans les délégués (C#)	Montre comment utiliser la prise en charge de la covariance et de la contravariance dans les délégués non génériques pour faire correspondre des signatures de méthode avec des types délégués.
Utilisation de la variance pour les délégués génériques Func et Action (C#)	Montre comment la prise en charge de la covariance et de la contravariance dans les délégués Func et Action peut vous aider à réutiliser du code.