Click here to Skip to main content
Click here to Skip to main content
Technical Blog

Tagged as

Covariance and Contravariance in C#

, 28 Mar 2010 CPOL
Rate this:
Please Sign up or sign in to vote.
Covariance and Contravariance in C#

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:

ContraCo

Figure: Class hierarchy
  1. 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[10];

    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[100];
  2. 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 which take no arguments but return animal
    delegate Animal copy(); 
    
    /// <span class="code-SummaryComment"><summary> 
    </span>/// method which delegate copy can accepts. 
    /// <span class="code-SummaryComment"></summary> 
    </span>/// <span class="code-SummaryComment"><returns>Mammal</returns> 
    </span>Mammal copyMammal() 
    { 
    return new Mammal(); 
    }

    The following statement is valid and an example of return type covariance.

    //an assignment statement where covariant occurs by allowing 
    //Mammal return type in place of Animal return type
    copy cfunc = copyMammal;
  3. Contravariance is supported in parameters. Let's take a look at the following code snippets for understanding how contravariance works in parameters types:
    //delegate which take one mammal argument and return nothing 
    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 delegate.

    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();
    cs2(tiger);

    If covariance would support here, then the above statement would generate an exception as cs2 can handle Giraffe but not Tiger.

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:

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Sohel_Rana
Architect ImpleVista Aps
Denmark Denmark
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

Comments and Discussions

 
GeneralMy vote of 3 Pinmemberram.yadav@viitonline6-May-11 21:51 
GeneralRe: My vote of 3 PinmemberRavi Sant17-Jun-11 4:43 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.1411023.1 | Last Updated 29 Mar 2010
Article Copyright 2009 by Sohel_Rana
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid