Understanding Covariance and Contravariance in C# Generic Interfaces

C# supports variance annotations for generic interfaces through the in and out keywords, enabling more flexible type conversions when working with generics.

The Fundamentals of Variance

At its core, variance refers to how type parameters in generic interfaces can be transformed:

• Covariance: Allows a more derived type to be used where a less derived one is expected.
• Contravariance: Allows a less derived type to be used where a more derived one is expected.

In C#, the standard type conversion follows a specific pattern: a subtype reference can be implicitly converted to a parent type reference (child → parent). Variance extends this concept to generic types.

Type Conversion in Method Signatures

Consider a method that transforms an input parameter:

public string ProcessInput(object input)
{
    return input.ToString();
}

This method signature involves two type conversion scenarios:

1. Input conversion: When passing arguments to the method, we can use a more specific type (e.g., string) where a more general one (e.g., object) is expected (parent ← child).
2. Output conversion: When receiving the return value, we can use a more general type (e.g., object) where a more specific one (e.g., string) was produced (child → parent).

Implementing Covariance with out

When a generic interface only uses its type parameter for output, we can apply the out modifier to enable covariance:

interface IReadableCollection<out T>
{
    T GetItem(int index);
}

public class StringCollection : IReadableCollection<string>
{
    private readonly string[] _items = { "First", "Second", "Third" };
    
    public string GetItem(int index)
    {
        return _items[index];
    }
}

With covariance, we can assign a more specific implementation to a more general interface reference:

IReadableCollection<string> stringCollection = new StringCollection();
IReadableCollection<object> objectCollection = stringCollection;

This works because the type parameter T is only used in output positions, allowing the conversion from IReadableCollection to IReadableCollection