C#2.0 Delegate Covariance

In C#2.0, the concept of covariance was introduced which allows converting a delegate from a more derived type to a less derived type. This concept is known as delegate covariance.

What is Covariance?

Covariance is the ability to convert a more specific type to a less specific type. In other words, a more derived type can be assigned to a less derived type. For example, we can assign string[] to an object[] because string is derived from object.

Delegate Covariance

Delegate covariance is a special case of covariance that applies to delegates. It allows a delegate of a more derived type to be assigned to a delegate of a less derived type.

Let's understand this with an example:

public delegate void ReportingDelegate(Employee employee);
public delegate void ManagerDelegate(Manager manager);

Here, ReportingDelegate is a delegate that takes an Employee object as an argument and ManagerDelegate is a delegate that takes a Manager object as an argument.

Now, if we have a method that accepts ReportingDelegate as an argument like below:

public void ReportToManagement(ReportingDelegate reporter)
{
    // report to management
}

We can pass a delegate of ManagerDelegate to this method because Manager is derived from Employee. This is delegate covariance in action.

public static void Main()
{
    ManagerDelegate manager = new ManagerDelegate(ReportManager);
    ReportToManagement(manager);
}

public static void ReportManager(Manager manager)
{
    // report manager details
}

Limitations

Delegate covariance works only with reference types and not with value types. Additionally, covariance is not applicable if the delegate has a return type other than void.

Conclusion

Delegate covariance is a powerful feature in C#2.0 that allows assigning a delegate of a more derived type to a delegate of a less derived type. It simplifies the code and makes it more reusable.