C# Casting Generic Type

Question

I have a generic interface IConstrained which is implemented by the generic Constrained class. When I attempt to do the code below I get an invalid cast exception.

IConstrained<decimal> decimalLimit = new Constrained<decimal>(1);
IConstrained<IComparable> comparableLimit = (IConstrained<IComparable>) decimalLimit;

Why is it not possible to do this if decimal implements IComparable? What would be the correct way to do this? Thanks.

Answer 1

Generic types are not covariant in .NET 2.0. This includes .NET 3.0/3.5 as well since they use the same 2.0 runtime. .NET 4.0 will support covariance, however.

Answer 2

Casting IConstrained<decimal> to IConstrained<IComparable> is called covariance. You can't do it in C# 3. However, it is coming in C# 4.

Erik Lippert has a series of blog posts detailing Contravariance and Covariance.

To get around it, you will have to cast the decimal to IComparable when you use it.

Answer 3

This is a common trip-up with C# (as well as other languages with Generics).

In C#, you can only cast to classes in a class hierarchy (superclasses, subclasses). But IConstrained<IComparable> is neither a superclass, nor a subclass of IConstrained<decimal>, even though decimal implements IComparable. The reason C# disallows this is because allowing it would mean you can do very bad things.

For a detailed explanation of why this is, check out this similar question

Answer 4

For a class to be castable like this it would need to implement both interfaces IConstrained<decimal> and IConstrained<IComparable>

class A:IConstrained<decimal>,IConstrained<IComparable>

It does not happen automatically, because .NET 2.0 does not implement covariance or contravariance. IConstrained<decimal> doesn't implement IConstrained<IComparable>. Yes, it is a but frustrating and counter intuitive. There will actually be some support for this kind of scenario in C# 4.0 in one form or another from what I understand. It is called covariance or contravariance.

Edit: I'm not familier with the Constrained class, but you might be able to construct a new Contrained<IComparable> and pass to it a decimal. If it had a constructor of the form Constrained<T> (T copyFrom) then you can declare a new Constrained<IComparable> and pass the decimal to it. Kind of like making a copy.

Edit 2: About half way down this page, search for "2.0", there is an example of how to work around this issue in .NET 2.0: http://blog.t-l-k.com/dot-net/2009/c-sharp-4-covariance-and-contravariance

Answer 5

Here's an answer to "how to do it".

IList<decimal> decimalLimit = new List<decimal>(1);
IEnumerable<IComparable> asComparable = decimalLimit.Cast<IComparable>();
IList<IComparable> comparableLimit = asComparable.ToList();

Answer 6

When it comes to generics, two instances of the same generic type with different type arguments have no direct relationship to each other. In other words:

IConstrained<decimal> !== IConstrained<IComparable>

This is a variance problem. Even though decimal is IComparable, IConstrained<decimal> is not IConstrained<IComparable>. I believe this kind of automatic conversion will be possible under C# 4.0 with its improved co/contravariance. However it is not possible with C# 3.0 or earlier.