Understanding C# Covariance And Contravariance (6) Typing issues

479 words

2 minutes

Understanding C# Covariance And Contravariance (6) Typing issues

2009-09-01

.NET

/

C#

/

C# 4.0

/

Covariance And Contravariance

Understanding C# covariance and contravariance:

Understanding C# covariance and contravariance (1) Delegates
Understanding C# covariance and contravariance (2) Interfaces
Understanding C# covariance and contravariance (3) Samples
Understanding C# covariance and contravariance (4) Arrays
Understanding C# covariance and contravariance (5) Higher-order functions
Understanding C# covariance and contravariance (6) Typing issues
Understanding C# covariance and contravariance (7) CLR
Understanding C# covariance and contravariance (8) Void

In each previous part, type implicit conversion is dicussed, which happen during the variances, like

function (method / delegate) conversion, as well as higher-order function conversion;
generic interface conversion;
array conversion.

Since C# 4.0 introduces new variance rules, which means in C# 4.0, types could be more convertible than C# 2.0 / 3.0, there could be potential typing issues for C# 4.0. If comparing some code between Visual Studio 2008 (C# 2.0 / 3.0) and Visual Studio 2010 Beta2 (C# 4.0), you can find that is true.

Delegate covariance / contravariance issues#

Take a look at this covariance sample:

1
Func<Base> baseFunc = () => new Base();
2
Func<Derived> derivedFunc = () => new Derived();
3

4
// This always prints "True".
5
Console.WriteLine(derivedFunc is Func<Derived>);
6
// Covariance is supported by C# 4.0.
7
// This prints "False" in C# 2.0 / 3.0, prints "True" in C# 4.0.
8
Console.WriteLine(derivedFunc is Func<Base>);

And this contravariance sample:

1
Action<Base> baseAction = arg => { };
2
Action<Derived> derivedAction = arg => { };
3

4
// This always prints "True".
5
Console.WriteLine(baseAction is Action<Base>);
6
// Contravariance is supported by C# 4.0.
7
// This prints "False" in C# 2.0 / 3.0, prints "True" in C# 4.0.
8
Console.WriteLine(baseAction is Action<Derived>);

Yes, in C# 4.0, delegate types are more convertable.

Interface covariance / contravariance issues#

This is the interface covariance on IEnumerator:

1
IEnumerator<Base> baseEnumerator = new BaseEnumerator();
2
IEnumerator<Derived> derivedEnumerator = new DerivedEnumerator();
3

4
// This always prints "True".
5
Console.WriteLine(derivedEnumerator is IEnumerator<Derived>);
6
// Covariance is supported by C# 4.0.
7
// This prints "False" in C# 2.0 / 3.0, prints "True" in C# 4.0.
8
Console.WriteLine(derivedEnumerator is IEnumerator<Base>);

It looks acceptable.

Then this is covariance on IEnumerable:

1
IEnumerable<Base> bases = new Base[0];
2
IEnumerable<Derived> deriveds = new Derived[0];
3

4
// This always prints "True".
5
Console.WriteLine(deriveds is IEnumerable<Derived>);
6
// Covariance is supported by C# 4.0.
7
// This prints "True" in C# 2.0 / 3.0 / 4.0.
8
Console.WriteLine(deriveds is IEnumerable<Base>);

Looks like a big mess.

To try interface contravariance, IComparable can be used as an example:

1
internal class Base : IComparable<Base>
2
{
3
    public int CompareTo(Base other)
4
    {
5
        throw new NotImplementedException();
6
    }
7
}
8

9
internal class Derived : Base
10
{
11
}

Then:

1
IComparable<Base> baseComparable = new Base();
2
// This cannot compile in C# 2.0 / 3.0,
3
// because Derived does not implement IComparable<Derived>.
4
IComparable<Derived> derivedComparable = new Derived();
5

6
// This always prints "True".
7
Console.WriteLine(baseComparable is IComparable<Base>);
8
// Contravariance is supported by C# 4.0.
9
// This prints "False" in C# 2.0 / 3.0, prints "True" in C# 4.0.
10
Console.WriteLine(baseComparable is IComparable<Derived>);

The interface variances are also confusing.

Conclusion#

C# 4.0 introduces new variance rules, so in C# 4.0, types becomes more convertible than C# 2.0 / 3.0. And this makes the same code work differently between C# 2.0 / 3.0 and C# 4.0.