Question about C# 4.0's generics covariance

Question

Having defined this interface:

public interface IInputBoxService<out T> {
    bool ShowDialog();
    T Result { get; }
}

Why does the following code work:

public class StringInputBoxService : IInputBoxService<string> {
    ...
}

...

IInputBoxService<object> service = new StringInputBoxService();

and this doesn't?:

public class IntegerInputBoxService : IInputBoxService<int> {
    ...
}

...

IInputBoxService<object> service = new IntegerInputBoxService();

Does it have anything to do with int being a value type? If yes, how can I circumvent this situation?

Thanks

Answer 1

Yes, it absolutely has to do with int being a value type. Generic variance in C# 4 only works with reference types. This is primarily because references always have the same representation: a reference is just a reference, so the CLR can use the same bits for something it knows is a string reference as for an object reference. The CLR can make sure that the code will be safe, and use native code which only knows about IInputBoxService<object> when passed an IInputBoxService<string> - the value returned from Result will be representationally compatible (if such a term exists!).

With int => object there would have to be boxing etc, so you don't end up with the same code - that basically messes up variance.

EDIT: The C# 4.0 spec says this in section 13.1.3.2:

The purpose of variance annotations is to provide for more lenient (but still type safe) conversions to interface and delegate types. To this end the definitions of implicit (§6.1) and explicit conversions (§6.2) make use of the notion of variance-convertibility, which is defined as follows: A type T is variance-convertible to a type T if T is either an interface or a delegate type declared with the variant type parameters T, and for each variant type parameter Xi one of the following holds:

• Xi is covariant and an implicit reference or identity conversion exists from Ai to Bi

• Xi is contravariant and an implicit reference or identity conversion exists from Bi to Ai

• Xi is invariant and an identity conversion exists from Ai to Bi

This doesn't make it terribly obvious, but basically reference conversions only exist between reference types, which leaves only identity conversions (i.e. from a type to itself).

As for workarounds: I think you'd have to create your own wrapper class, basically. This can be as simple as:

public class Wrapper<T>
{
    public T Value { get; private set; }
    public Wrapper(T value)
    {
        Value = value;
    }
}

It's pretty nasty though :(