Understanding C# Covariance and Contravariance (1) Delegates

Understanding C# Covariance And Conreavariance:

In Covariance/contravariance, variance is the capability to replace a type with a less-derived type or a more-derived type in a context. C# 4.0 and CLR 4 introduced covariance and contravariance for generics.

Is-a relationship for inheritance#

Since covariance and contravariance is about deriving, the following inheritance hierarchy is defined:

1
public class Base
2
{
3
}
4

5
public class Derived : Base
6
{
7
}

Apparently, a Derived object “is a” Base object.

Non-generic delegate#

By using above Base/Derived as input/output of method, there are 4 combinations:

1
public static class Methods
2
{
3
    public static Base DerivedIn_BaseOut(Derived @in)
4
    {
5
        return new Base();
6
    }
7

8
    public static Derived DerivedIn_DerivedOut(Derived @in)
9
    {
10
        return new Derived();
11
    }
12

13
    public static Base BaseIn_BaseOut(Base @in)
14
    {
15
        return new Base();
16
    }
17

18
    public static Derived BaseIn_DerivedOut(Base @in)
19
    {
20
        return new Derived();
21
    }
22
}

Bind method to a delegate#

Before C# 4.0, C# already supported covariance and contravariance for delegates without generics. Consider the following delegate type:

1
public delegate Base DerivedIn_BaseOut(Derived @in);

Above Methods.DerivedIn_BaseOut’s signature matches this delegate type, so Methods.DerivedIn_BaseOut can be bound to its delegate instance:

1
public static partial class NonGenericDelegate
2
{
3
    public static void Bind()
4
    {
5
        // Binding: DerivedIn_BaseOut delegate type and DerivedIn_BaseOut method have exactly the same signature.
6
        DerivedIn_BaseOut derivedIn_BaseOut = Methods.DerivedIn_BaseOut;
7

8
        // When calling derivedIn_BaseOut delegate instance, DerivedIn_BaseOut method executes.
9
        Base @out = derivedIn_BaseOut(@in: new Derived());
10
    }
11
}

Covariance#

Methods.DerivedIn_DerivedOut has a different signature from DerivedIn_BaseOut delegate type. The former returns a more derived type. There is a “is-a” relationship between their return types, but there is no intuitive relationship between the two signatures.

However, C# compiler and the CLR both allow the following binding (assignment) before C# 4.0:

1
public static partial class NonGenericDelegate
2
{
3
    public static void Covariance()
4
    {
5
        // Covariance: Derived "is a" Base => DerivedIn_DerivedOut "is a" DerivedIn_BaseOut.
6
        DerivedIn_BaseOut derivedIn_DerivedOut = Methods.DerivedIn_DerivedOut;
7

8
        // When calling derivedIn_BaseOut delegate instance, DerivedIn_DerivedOut method executes.
9
        // derivedIn_BaseOut should output a Base object, while DerivedIn_DerivedOut outputs a Derived object.
10
        // The actual Derived object "is a" required Base output. This binding always works.
11
        Base @out = derivedIn_DerivedOut(@in: new Derived());
12
    }
13
}

Here a bound method can return a more derived type than the delegate type. This is called covariance.

Contravariance#

Methods.BaseIn_BaseOut required a less-derived parameter then DerivedIn_BaseOut delegate type. The following binding also works before C# 4.0:

1
public static partial class NonGenericDelegate
2
{
3
    public static void Contravariance()
4
    {
5
        // Contravariance: Derived is a Base => BaseIn_BaseOut is a DerivedIn_BaseOut.
6
        DerivedIn_BaseOut derivedIn_BaseOut = Methods.BaseIn_BaseOut;
7

8
        // When calling derivedIn_BaseOut delegate instance, BaseIn_BaseOut method executes.
9
        // derivedIn_BaseOut should have a Derived input, while BaseIn_BaseOut requires a Base input.
10
        // The actual Derived object "is a" required Base input. This binding always works.
11
        Base @out = derivedIn_BaseOut(@in: new Derived());
12
    }
13
}

Here a method can have less derived parameter type than the delegate type. This is called contravariance.

Covariance and contravariance#

It is easy to predict, Methods.BaseIn_DerivedOut, with more derived parameter type and less derived return type, can be also bound to DerivedIn_BaseOut:

1
public static partial class NonGenericDelegate
2
{
3

4
    public static void CovarianceAndContravariance()
5
    {
6
        // Covariance and contravariance: Derived is a Base => BaseIn_DerivedOut is a DerivedIn_BaseOut.
7
        DerivedIn_BaseOut derivedIn_BaseOut = Methods.BaseIn_DerivedOut;
8

9
        // When calling derivedInBaseOut delegate instance, BaseIn_DerivedOut method executes.
10
        // derivedIn_BaseOut should have a Derived input, while BaseIn_DerivedOut requires a Base input.
11
        // derivedIn_BaseOut should output a Base object, while BaseIn_DerivedOut outputs a Derived object.
12
        // This binding always works.
13
        Base @out = derivedIn_BaseOut(@in: new Derived());
14
    }
15
}

Here covariance and contravariance both happen for the same binding.

Invalid variance#

In the following bindings, there is no valid variance, so they cannot be compiled:

1
public static partial class NonGenericDelegate
2
{
3
    public delegate Derived BaseIn_DerivedOut(Base @base);
4

5
    public static void InvalidVariance()
6
    {
7
#if Uncompilable
8
        // baseIn_DerivedOut should output a Derived object, while BaseIn_DerivedOut outputs a Base object.
9
        // Base is not Derived, the following binding cannot be compiled.
10
        BaseIn_DerivedOut baseIn_DerivedOut1 = Methods.BaseIn_BaseOut;
11

12
        // baseIn_DerivedOut should have a Base input, while DerivedIn_BaseOut required a Derived output.
13
        // Base is not a Derived, the following binding cannot be compiled.
14
        BaseIn_DerivedOut baseIn_DerivedOut2 = Methods.DerivedIn_BaseOut;
15

16
        // baseIn_DerivedOut should have a Base input, while DerivedIn_DerivedOut required a Derived input.
17
        // baseIn_DerivedOut should output a Derived object, while derivedIn_DerivedOut outputs a Base object.
18
        // Base is not a Derived, the following binding cannot be compiled.
19
        BaseIn_DerivedOut baseIn_DerivedOut3 = Methods.DerivedIn_DerivedOut;
20
#endif
21
    }
22
}

Is-a relationship of delegates#

The root of variances is that, in inheritance hierarchy, derived object “is a” base object. This “is-a” relationship can be promoted to a relationship between method and delegate types:

Covariance of output: Derived is a Base => DerivedIn_DerivedOut is a DerivedIn_BaseOut;
Contravariance of input: Derived is a Base => BaseIn_BaseOut is a DerivedIn_BaseOut;
Covariance of output and contravariance of input: Derived is a Base => BaseIn_DerivedOut is a DerivedIn_BaseOut.

Please notice these rules does not apply to value types. Basically value types has nothing to do with covariance/contravariance.

Generic delegate#

With C# 2.0 generic delegate, the above XxxIn_XxxOut delegate types can be represented by the following:

1
public delegate TOut Func<TIn, TOut>(TIn @in);

Then above method bindings become:

1
public static partial class GenericDelegateWithVariances
2
{
3
    public static void BindMethods()
4
    {
5
        // Bind.
6
        Func<Derived, Base> derivedIn_BaseOut1 = Methods.DerivedIn_BaseOut;
7

8
        // Covariance.
9
        Func<Derived, Base> derivedIn_BaseOut2 = Methods.DerivedIn_DerivedOut;
10

11
        // Contravariance.
12
        Func<Derived, Base> derivedIn_BaseOut3 = Methods.BaseIn_BaseOut;
13

14
        // Covariance and contravariance.
15
        Func<Derived, Base> derivedIn_BaseOut4 = Methods.BaseIn_DerivedOut;
16
    }
17
}

C# 3.0 introduced lambda expression. However, the above bindings cannot be used for lambda expression:

1
public static partial class GenericDelegate
2
{
3
    public static void BindLambdas()
4
    {
5
        Func<Derived, Base> derivedIn_BaseOut = (Derived @in) => new Base();
6
        Func<Derived, Derived> derivedIn_DerivedOut = (Derived @in) => new Derived();
7
        Func<Base, Base> baseIn_BaseOut = (Base @in) => new Base();
8
        Func<Base, Derived> baseIn_DerivedOut = (Base @in) => new Derived();
9

10
#if Uncompilable
11
        // Covariance.
12
        derivedIn_BaseOut = derivedIn_DerivedOut;
13

14
        // Contravariance.
15
        derivedIn_BaseOut = baseIn_BaseOut;
16

17
        // Covariance and contravariance.
18
        derivedIn_BaseOut = baseIn_DerivedOut;
19
#endif
20
    }
21
}

The out and in keywords#

C# 4.0 uses the in/out keywords to specify a type parameter is contravariant/covariant. So above generic delegate can be defined as:

1
public delegate TOut Func<in TIn, out TOut>(TIn @in);

Now the bindings work for both methods and lambda expressions:

1
public static partial class GenericDelegateWithVariances
2
{
3
    public static void BindMethods()
4
    {
5
        // Bind.
6
        Func<Derived, Base> derivedIn_BaseOut1 = Methods.DerivedIn_BaseOut;
7

8
        // Covariance.
9
        Func<Derived, Base> derivedIn_BaseOut2 = Methods.DerivedIn_DerivedOut;
10

11
        // Contravariance.
12
        Func<Derived, Base> derivedIn_BaseOut3 = Methods.BaseIn_BaseOut;
13

14
        // Covariance and contravariance.
15
        Func<Derived, Base> derivedIn_BaseOut4 = Methods.BaseIn_DerivedOut;
16
    }
17

18
    public static void BindLambdas()
19
    {
20
        Func<Derived, Base> derivedIn_BaseOut = (Derived @in) => new Base();
21
        Func<Derived, Derived> derivedIn_DerivedOut = (Derived @in) => new Derived();
22
        Func<Base, Base> baseIn_BaseOut = (Base @in) => new Base();
23
        Func<Base, Derived> baseIn_DerivedOut = (Base @in) => new Derived();
24

25
        // Covariance.
26
        derivedIn_BaseOut = derivedIn_DerivedOut;
27

28
        // Contravariance.
29
        derivedIn_BaseOut = baseIn_BaseOut;
30

31
        // Covariance and ontravariance.
32
        derivedIn_BaseOut = baseIn_DerivedOut;
33
    }
34
}

The in/out keywords also constrains the usage of the decorated type parameter to guarantee the variances. The following generic delegate types are invalid and cannot be compiled:

1
public static partial class GenericDelegateWithVariances
2
{
3
#if Uncompilable
4
    // CS1961 Invalid variance: The type parameter 'TOut' must be covariantly valid on 'GenericDelegateWithVariances.Func<TOut>.Invoke()'. 'TOut' is contravariant.
5
    public delegate TOut Func<in TOut>();
6

7
    // CS1961 Invalid variance: The type parameter 'TIn' must be contravariantly valid on 'GenericDelegateWithVariances.Action<TIn>.Invoke(TIn)'. 'TIn' is covariant.
8
    public delegate void Action<out TIn>(TIn @in);
9

10
    // CS1961 Invalid variance: The type parameter 'TOut' must be covariantly valid on 'GenericDelegateWithVariances.Func<TIn, TOut>.Invoke(TIn)'. 'TOut' is contravariant.
11
    // CS1961 Invalid variance: The type parameter 'TIn' must be contravariantly valid on 'GenericDelegateWithVariances.Func<TIn, TOut>.Invoke(TIn)'. 'TIn' is covariant.
12
    public delegate TOut Func<out TIn, in TOut>(TIn @in);
13
#endif
14
}

So far, it looks in is only for input, and out is only for output. In .NET 4.0+:

1
namespace System
2
{
3
    public delegate TOut Func<out TOut>();
4

5
    public delegate TOut Func<out TOut, in TIn>(TIn @in);
6

7
    public delegate TOut Func<out TOut, in TIn1, in TIn2>(TIn1 in1, TIn2 in2);
8

9
    public delegate TOut Func<out TOut, in TIn1, in TIn2, in TIn3>(TIn1 in1, TIn2 in2, TIn3 in3);
10

11
    // ...
12

13
    public delegate void Action<in TIn>(TIn @in);
14

15
    public delegate void Action<in TIn1, in TIn2>(TIn1 in1, TIn2 in2);
16

17
    public delegate void Action<in TIn1, in TIn2, in TIn3>(TIn1 in1, TIn2 in2, TIn3 in3);
18

19
    // ...
20
}

The type parameter is renamed to be more intuitive.