{"id":1387,"date":"2023-04-05T07:35:32","date_gmt":"2023-04-05T00:35:32","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=1387"},"modified":"2023-04-05T08:55:12","modified_gmt":"2023-04-05T01:55:12","slug":"csharp-covariance","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-tutorial\/csharp-covariance\/","title":{"rendered":"C# Covariance"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about C# covariance that allows you to write more flexible generic code.<\/p>\n\n\n\n

Introduction to C# Covariance<\/h2>\n\n\n\n

Inheritance<\/a> allows you to define an is-a relationship between classes<\/a>. For example, an employee is a person. Therefore, you can define an Employee<\/code> class that inherits from a Person<\/code> class like this:<\/p>\n\n\n

class<\/span> Person<\/span>\n{\n    public<\/span> string<\/span> Name  { get<\/span>; set<\/span>;}\n    public<\/span> Person<\/span>(string<\/span> name<\/span>)<\/span>\n    {\n        Name = name;\n    }\n}\n\nclass<\/span> Employee<\/span> : Person<\/span>\n{\n    public<\/span> string<\/span> JobTitle { get<\/span>; set<\/span>;}\n\n    public<\/span> Employee<\/span>(string<\/span> name, string<\/span> jobTitle<\/span>) : base<\/span>(name<\/span>)<\/span>\n    {\n        JobTitle = jobTitle;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In C#, covariance means the order is the same<\/strong> as an inheritance. For example, a list of employees is a list of people. So a list is covariant<\/strong>.<\/p>\n\n\n\n
To define a covariance, you use the out<\/code> keyword. For example: <\/p>\n\n\n
interface<\/span> MyInterface<\/span><out<\/span> T<\/span>>\n<\/span>{\n}<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
The keyword out<\/code> means that you can only return T<\/code> from the methods of the interface. In other words, you cannot<\/strong> use T<\/code> as the parameter of any method.  For example:<\/p>\n\n\n
interface<\/span> MyInterface<\/span><out<\/span> T<\/span>>\r\n<\/span>{\r\n    T GetNext();\r\n}<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
But the following example will result in an error because we use T<\/code> as the parameter of the Add()<\/code> method:<\/p>\n\n\n
interface<\/span> MyInterface<\/span><out<\/span> T<\/span>>\r\n<\/span>{\r\n    T GetNext();\r\n\r\n    \/\/ Invalid variance: The type parameter 'T' must be contravariantly<\/span>\r\n    \/\/ valid on 'MyInterface<T>.Add(T)'.'T' is covariant<\/span>\r\n    void Add(T item); \/\/ ERROR<\/span>\r\n}<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
.NET has many built-in generic interfaces that are covariant, for example, the IEnumerable<T><\/code> interface:<\/p>\n\n\n
public<\/span> interface<\/span> IEnumerable<\/span><out<\/span> T<\/span>> : System<\/span>.Collections<\/span>.IEnumerable<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Because IEnumerable<T><\/code> is a covariance, you can assign a list of Employee<\/code> objects to a list of Person<\/code> objects like this:<\/p>\n\n\n
IEnumerable<Employee> employees = new<\/span> List<Employee>()\n{\n    new<\/span> Employee(\"John Doe\"<\/span>,\"C# Developer\"<\/span>),\n    new<\/span> Employee(\"Jane Doe\"<\/span>,\"UI\/UX Designer\"<\/span>)\n};\n\nIEnumerable<Person> people = employees;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
This example shows that the Employee<\/code> object is upcasted to the Person<\/code> object. If the IEnumerable<T><\/code> is not a covariant, the code will not compile.<\/p>\n\n\n\n
Also, you can pass a list of Employee<\/code> object to a method that accepts a list of Person<\/code> object like the following example:<\/p>\n\n\n
using<\/span> static<\/span> System.Console;\n\nclass<\/span> Person<\/span>\n{\n    public<\/span> string<\/span> Name\n    {\n        get<\/span>; set<\/span>;\n    }\n    public<\/span> Person<\/span>(string<\/span> name<\/span>)<\/span>\n    {\n        Name = name;\n    }\n}\n\nclass<\/span> Employee<\/span> : Person<\/span>\n{\n    public<\/span> string<\/span> JobTitle\n    {\n        get<\/span>; set<\/span>;\n    }\n\n    public<\/span> Employee<\/span>(string<\/span> name, string<\/span> jobTitle<\/span>) : base<\/span>(name<\/span>)<\/span>\n    {\n        JobTitle = jobTitle;\n    }\n}\n\n\nclass<\/span> Program<\/span>\n{\n    public<\/span> static<\/span> void<\/span> Display<\/span>(IEnumerable<Person> people<\/span>)<\/span>\n    {\r\n\r        foreach<\/span> (var<\/span> person in<\/span> people)\n        {\n            WriteLine(person.Name);\n        }\n    }\n\n    public<\/span> static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        IEnumerable<Employee> employees = new<\/span> List<Employee>()\n        {\n            new<\/span> Employee(\"John Doe\"<\/span>,\"C# Developer\"<\/span>),\n            new<\/span> Employee(\"Jane Doe\"<\/span>,\"UI\/UX Designer\"<\/span>)\n        };\n        Display(employees);\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
John Doe\nJane Doe<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Defining a covariant interface in C#<\/h2>\n\n\n\n
The following example defines the IGroup<T><\/code> interface and Group<T><\/code> class that implements the IGroup<T><\/code> interface.<\/p>\n\n\n
using<\/span> static<\/span> System.Console;\n\nclass<\/span> Person<\/span>\n{\n    public<\/span> string<\/span> Name\n    {\n        get<\/span>; set<\/span>;\n    }\n    public<\/span> Person<\/span>(string<\/span> name<\/span>)<\/span>\n    {\n        Name = name;\n    }\n}\n\nclass<\/span> Employee<\/span> : Person<\/span>\n{\n    public<\/span> string<\/span> JobTitle\n    {\n        get<\/span>; set<\/span>;\n    }\n\n    public<\/span> Employee<\/span>(string<\/span> name, string<\/span> jobTitle<\/span>) : base<\/span>(name<\/span>)<\/span>\n    {\n        JobTitle = jobTitle;\n    }\n}\n\ninterface<\/span> IGroup<\/span><out<\/span> T<\/span>>\n{\r\n    IEnumerable<T> GetAll<\/span>(<\/span>)<\/span>;\n}\n\nclass<\/span> Group<\/span><T<\/span>> : IGroup<\/span><T<\/span>>\n{\r\n    private<\/span> readonly<\/span> List<T> list = new<\/span>();\r\n    public<\/span> Group<\/span>(List<T> list<\/span>)<\/span>\r\n    {\r\n        this<\/span>.list = list;\r\n    }\r\n    public<\/span> IEnumerable<T> GetAll<\/span>(<\/span>)<\/span> => list;\r\n}\n\nclass<\/span> Program<\/span>\n{\r\n    public<\/span> static<\/span> void<\/span> Display<\/span>(IGroup<Person> people<\/span>)<\/span>\r\n    {\r\n        foreach<\/span> (var<\/span> person in<\/span> people.GetAll())\r\n        {\r\n            WriteLine(person.Name);\r\n        }\r\n    }\r\n\r\n    public<\/span> static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\r\n    {\r\n        var<\/span> employees = new<\/span> List<Employee>()\r\n        {\r\n            new<\/span> Employee(\"John Doe\"<\/span>,\"C# Developer\"<\/span>),\r\n            new<\/span> Employee(\"Jane Doe\"<\/span>,\"UI\/UX Developer\"<\/span>)\r\n        };\r\n\r\n        IGroup<Employee> employeeGroup = new<\/span> Group<Employee>(employees);\r\n        \r\n        Display(employeeGroup);\r\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
If you remove the out keyword from the IGroup<out T> interface, the program will not compile and return the following error:<\/p>\n\n\n
Cannot implicitly convert type 'IGroup<Employee>'<\/span> to 'IGroup<Person>'<\/span>. An explicit<\/span> conversion exists<\/span> (are you missing a cast?<\/span>)<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Summary<\/h2>\n\n\n\n
    \n
  • Covariance means that when you have a hierarchy of classes or interfaces, a method in a derived class or interface can return a more specific type than the same method in its base class or interface.<\/li>\n\n\n\n
  • Covariance allows you to write more flexible and adaptable code.<\/li>\n\n\n\n
  • Use the out keyword to define a covariance.<\/li>\n<\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t\n\t\t\t
By definition, covariance<\/strong> allows a derived class or interface to return a more derived type that is returned by the base class or interface method. C# supports the covariance in generic interfaces<\/a> and delegates<\/a>.<\/p>\n\n\n\n