演员表 <string> 到MyClass <object> 运行时失败

Question

In developing a class that should handle various generic lambda expressions, I fell into a rather familiar hole: I had a MyClass<T> class, and I tried to cast MyClass<string> to MyClass<object> , like so:

MyClass<string> myClassString = GetMyClass(); // Returns MyClass<String>
MyClass<object> myClassObject = myClassString;

Doing so returned an compilation error saying there there's no implicit conversion between the two types, but that an explicit conversion does exist. So I added the explicit conversion:

MyClass<object> myClassObject = (MyClass<object>)myClassString;

Now the code compiled, but failed in runtime, claiming the conversion is illegal.

I am using Visual Studio 2012, and the code is part of a Portable Class Library project compiled with C# 5.

Just to make sure, I replaced MyClass IList - the same behavior appeared - an explicit conversion is allowed, but fails during run-time.

Why? Why does the compiler accept this? What's the point of the explicit conversion if it fails in runtime?

Answer 1

In order to allow the cast, you need to mark it as covariant. However, covariance is only allowed for interfaces (and delegates). This would look like:

interface MyInterface<out T> ...

The reason why you can compile the explicit cast is probably that the compiler assumes that the return value of GetMyClass() could be a MyClass<object> . But That's hard to say without the declaration.

Answer 2

To be able to cast MyClass<string> to MyClass<object> you need to fulfill the following:

• MyClass<T> must be an interface, eg IMyClass<T> .
• You need to add the out keyword to the type parameter T , making the type parameter covariant .
• The type parameter T may only appear in output positions of the members of the interface.

For example:

public interface IMyClass<out T>
{
    T GetItem();    // T in an output position
}

Now you can cast it:

IMyClass<string> myClassString;
IMyClass<object> myClassObject = (IMyClass<object>)myClassString;

Answer 3

If you have classes A and B and you want to cast B to A then one of the following must be true:

• B derives/implements A or vice versa
• There is an explicit cast operator defined from B to A

None of the above is true in your case so the cast is invalid.

If your class implements IEnumerable you may use an extension method

using System.Linq
...
MyClass<Object> asObject = GetMyClass().Cast<Object>();

Otherwise, write an explicit operator or function that does the conversion:

public MyClass<Base> ConvertToBase<Base, Derived>(MyClass<Derived>) where Derived : Base
{
    // construct and return the appropriate object
}

Answer 4

use Conversion operator to implement casting of your class to another classes

http://msdn.microsoft.com/en-us/library/85w54y0a.aspx

http://msdn.microsoft.com/en-us/library/09479473(v=vs.80).aspx