Summary: in this tutorial, you’ll learn about C# covariance that allows you to write more flexible generic code.
Introduction to C# Covariance
Inheritance allows you to define an is-a relationship between classes. For example, an employee is a person. Therefore, you can define an Employee class that inherits from a Person class like this:
class Person { public string Name { get; set;} public Person(string name) { Name = name; } } class Employee : Person { public string JobTitle { get; set;} public Employee(string name, string jobTitle) : base(name) { JobTitle = jobTitle; } }Code language: C# (cs)In C#, covariance means the order is the same as an inheritance. For example, a list of employees is a list of people. So a list is covariant.
By definition, covariance 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 and delegates.
To define a covariance, you use the out keyword. For example:
interface MyInterface<out T> { }Code language: PHP (php)The keyword out means that you can only return T from the methods of the interface. In other words, you cannot use T as the parameter of any method. For example:
interface MyInterface<out T> { T GetNext(); }Code language: PHP (php)But the following example will result in an error because we use T as the parameter of the Add() method:
interface MyInterface<out T> { T GetNext(); // Invalid variance: The type parameter 'T' must be contravariantly // valid on 'MyInterface<T>.Add(T)'.'T' is covariant void Add(T item); // ERROR }Code language: PHP (php).NET has many built-in generic interfaces that are covariant, for example, the IEnumerable<T> interface:
public interface IEnumerable<out T> : System.Collections.IEnumerableCode language: C# (cs)Because IEnumerable<T> is a covariance, you can assign a list of Employee objects to a list of Person objects like this:
IEnumerable<Employee> employees = new List<Employee>() { new Employee("John Doe","C# Developer"), new Employee("Jane Doe","UI/UX Designer") }; IEnumerable<Person> people = employees;Code language: C# (cs)This example shows that the Employee object is upcasted to the Person object. If the IEnumerable<T> is not a covariant, the code will not compile.
Also, you can pass a list of Employee object to a method that accepts a list of Person object like the following example:
using static System.Console; class Person { public string Name { get; set; } public Person(string name) { Name = name; } } class Employee : Person { public string JobTitle { get; set; } public Employee(string name, string jobTitle) : base(name) { JobTitle = jobTitle; } } class Program { public static void Display(IEnumerable<Person> people) { foreach (var person in people) { WriteLine(person.Name); } } public static void Main(string[] args) { IEnumerable<Employee> employees = new List<Employee>() { new Employee("John Doe","C# Developer"), new Employee("Jane Doe","UI/UX Designer") }; Display(employees); } }Code language: C# (cs)Output:
John Doe Jane DoeCode language: C# (cs)Defining a covariant interface in C#
The following example defines the IGroup<T> interface and Group<T> class that implements the IGroup<T> interface.
using static System.Console; class Person { public string Name { get; set; } public Person(string name) { Name = name; } } class Employee : Person { public string JobTitle { get; set; } public Employee(string name, string jobTitle) : base(name) { JobTitle = jobTitle; } } interface IGroup<out T> { IEnumerable<T> GetAll(); } class Group<T> : IGroup<T> { private readonly List<T> list = new(); public Group(List<T> list) { this.list = list; } public IEnumerable<T> GetAll() => list; } class Program { public static void Display(IGroup<Person> people) { foreach (var person in people.GetAll()) { WriteLine(person.Name); } } public static void Main(string[] args) { var employees = new List<Employee>() { new Employee("John Doe","C# Developer"), new Employee("Jane Doe","UI/UX Developer") }; IGroup<Employee> employeeGroup = new Group<Employee>(employees); Display(employeeGroup); } }Code language: C# (cs)If you remove the out keyword from the IGroup<out T> interface, the program will not compile and return the following error:
Cannot implicitly convert type 'IGroup<Employee>' to 'IGroup<Person>'. An explicit conversion exists (are you missing a cast?)Code language: C# (cs)Summary
- 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.
- Covariance allows you to write more flexible and adaptable code.
- Use the out keyword to define a covariance.
