Covariantie en Contravariantie (C#)

In C# maken covariantie en contravariantie impliciete verwijzingsconversie mogelijk voor matrixtypen, gedelegeerdentypen en algemene typeargumenten. Covariantie behoudt de compatibiliteit van toewijzingen en contravariantie keert deze om.

De volgende code toont het verschil tussen toewijzingscompatibiliteit, covariantie en contravariantie.

// 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;  

Covariantie voor matrices maakt impliciete conversie mogelijk van een matrix van een meer afgeleid type naar een matrix van een minder afgeleid type. Maar deze bewerking is niet veilig, zoals wordt weergegeven in het volgende codevoorbeeld.

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

Covariantie- en contravariantieondersteuning voor methodegroepen maakt het mogelijk om methodesignaturen af te stemmen op gedelegeerdentypen. Hiermee kunt u niet alleen methoden toewijzen aan gedelegeerden die overeenkomende handtekeningen hebben, maar ook methoden die meer afgeleide typen (covariantie) retourneren of parameters accepteren die minder afgeleide typen (contravariantie) hebben dan die zijn opgegeven door het gemachtigdetype. Voor meer informatie, zie Variantie in Delegaten (C#) en Variantie gebruiken in Delegaten (C#).

In het volgende codevoorbeeld ziet u covariantie- en contravariantieondersteuning voor methodegroepen.

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;  
}  

In .NET Framework 4 en latere versies ondersteunt C# covariantie en contravariantie in algemene interfaces en gemachtigden en maakt impliciete conversie van algemene typeparameters mogelijk. Zie Variantie in algemene interfaces (C#) en variantie in Gemachtigden (C#) voor meer informatie.

In het volgende codevoorbeeld ziet u impliciete verwijzingsconversie voor algemene interfaces.

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

Een interface of delegate wordt variant genoemd als de generieke parameters covariant of contravariant worden gedeclareerd. Met C# kunt u uw eigen variantinterfaces en gemachtigden maken. Zie voor meer informatie Generieke Variantie-interfaces (C#) maken en Variantie in Delegaten (C#).

Verwante onderwerpen