In C#, roughly we can say that covariance means we can substitute derived type in place of base type. Contravariance means we can substitute base class in place of derived class (you are thinking it's not possible, right? We'll see how it's possible). To get a detailed discussion on what covariance and contravariance are, follow the great post on Eric Lippert's Blog or Visit Wikipedia
In C#, covariance and contravariance are supported only for reference types. We will discuss few covariance and contravariance supports in C#. For this example, just take a look at the following class hierarchy as we are going to use the class hierarchy for all the examples in this post:
Figure: Class hierarchy
- From C# 1.0, arrays where the element type is reference type are covariant. For example, the following statement in C# is OK.
Animal animals=new Mammal;
In the above code,
mammal can be stored in animals array as mammal is derived from
Animal. But remember, this is only true for reference types. Why this covariance only for reference types but not for value type? It's because for reference types, the array originally keeps only pointers to the original object and base pointer can refer to derived types. In case of value type, the original value is stored in array itself so the size may vary depending on the type. So covariance is not supported for array of values. For example, the following statement will not compile:
long arr = new int;
- Covariance from method to delegates were included in C# 2.0. In the following code snippets (which is valid in C# 2.0 and later), you'll find that return type supports covariant. The original delegate has return type of
Animal. But the method we have assigned (here,
CopyMammal) to a variable (here,
cfunc) has return type
Mammal. So we can see that covariance is supported in return types.
delegate Animal copy();
</span>/// method which delegate copy can accepts.
/// <span class="code-SummaryComment"></summary>
</span>/// <span class="code-SummaryComment"><returns>Mammal</returns>
return new Mammal();
The following statement is valid and an example of return type covariance.
copy cfunc = copyMammal;
- Contravariance is supported in parameters. Let's take a look at the following code snippets for understanding how contravariance works in parameters types:
delegate void CopyState(Mammal a);
void copyMammalState(Mammal mammal)
void copyAnimalState(Animal mammal)
void CopyGiraffeSate(Giraffe giraffe)
Now the following code will compile as contravariance is supported here. This is contravariance since we are using
Animal parameter of
CopyAnimalState in place of
Mammal defined in
CopyState cs1 = copyAnimalState;
But the following code will not be supported as covariance is not supported in parameters.
CopyState cs2 = CopyGiraffeSate;
The above is not valid in C#. But why is it not valid? Let's explain a bit. For the sake of argument, think that the above statement is valid. Then anybody can call the
cs2 with a
Tiger element as shown below:
CopyState cs2 = CopyGiraffeSate;
Tiger tiger = new Tiger();
If covariance would support here, then the above statement would generate an exception as
cs2 can handle
Giraffe but not
C# 4.0 has extended the co and contravariance further for generic types and interfaces. Hope I'll post on it later. Some useful links on covariance and contravariance are as follows:
Sohel has more than six years of experience in professional software development with extensive involvement in Web based Object-Oriented, Multi-Tiered application design and development. He's Familiar with Test Driven Development (TDD) and refactoring techniques as well as having expertise in architecturing large enterprise applications. He has Experience in working with Content Management System and Portal Management System tools like SharePoint, DotNetNuke, Ektron.
Over last few years, he’s involved in development with projects on Microsoft SharePoint and received Microsoft MVP for SharePoint Server Development in the year 2011 and 2012. Currently he's working in a software company located Copenhagen,Denmark on a project integrating SharePoint and SAP. You can read his popular blog at: http://ranaictiu-technicalblog.blogspot.com