投泛型类型的失败

Question

我无法投泛型类型到另一种泛型类型，除了演员应该是有效的

我想存档是在短期（为MyModel实施IModel和MyImplementation实施IImplementation） ：

IImplementation<IModel> implementation = new MyImplementation<MyModel>(); 
Assert.IsNull(implementation as IImplementation<IModel>); 

这有点令人困惑，因为类型应该是有效的。

完整的概念模型：

interface IModel {} 

class MyModel : IModel {} 

interface IImplementation<TModel> where TModel : IModel { } 

class MyImplementation<TModel> : IImplementation<TModel> 
    where TModel : IModel { } 

public void CallRegister() 
{ 
    var implementation = new MyImplementation<MyModel>(); 
    var instance = CastModel(implementation); 
    Assert.IsNotNull(instance); //this assert fails! 
} 

private object CastModel<TModel>(IImplementation<TModel> implementation) where TModel : IModel 
{ 
    return implementation as IImplementation<IModel>; 
} 

我需要这个转换，使我能够多IImplementation S保存到同一Dictionary<Type, IImplementation<IModel>>，这里的关键是通过做typeof(TModel)获得。 要做到这一点类型安全我不想使用Dictionary<Type, object>。

• 为什么演员表失败？有没有额外的资源呢？它与Invalid Cast of Type Constrained C# Generic类似的问题，但它不解释为什么只是它不起作用。
• 如果这种类型的转换是不可能的，如上所述的归档类似于字典的功能的最佳方式是什么？

Answer 1

这种转换不允许有很好的理由。我们举一个问题更为明显的例子。我们有类Animal,Cat : Animal和Dog : Animal。现在让我们这样做：

List<Animal> list = new List<Cat>(); // Seems to be possible at first glance. 
// An now comes the problem: 
list.Add(new Dog()); // Seems to be possible as well. 

但是等等！这份名单实际上是猫的名单！我们正在尝试添加一条狗。即使将new Animal()添加到list（静态类型为List<Animal>）也不起作用。

因此，两种类型T<A>和T<B>在C＃中不是分配兼容的，即使A和B都是！

您需要另一种方法。

---

你可以做的是用带泛型类型约束的泛型方法来包装你的字典。

public class MyImplementationDict 
{ 
    private readonly Dictionary<Type, object> _internalDict = new Dictionary<Type, object>(); 

    public void Add<T>(IImplementation<T> item) 
     where T : IModel 
    { 
     _internalDict.Add(typeof(T), item); 
    } 

    ... 
} 

Answer 2

虽然奥利弗的回答有想法跨越为什么这通常出现问题，有一种方法，使你的程序这项工作。

你想要的功能被称为通用接口协方差。协方差是如果Cat是Animal，那么IFoo<Cat>是IFoo<Animal>。

协方差在C＃只能在以下情况下：

• 的“外”类型是一个接口，委托或阵列。没有类或结构。
• 如果接口或委托，类型必须在编译时标记为支持协方差。数组可以免费得到（不安全！）协方差。
• “内部”类型 - 变化的类型 - 都是参考类型。即使int是object，也不能说IFoo<int>是IFoo<object>，因为它们不是两种引用类型。

要标记的接口协变，你把out你希望允许改变类型参数的声明之前：

interface IImplementation<out TModel> where TModel : IModel { } 

如果你这样做，你的程序将开始工作。

无论其，out是提醒你，如果T在输出位置使用协是唯一安全的。这是合法的：

interface I<out T> { 
    T M(); 
} 

这不是：

interface I<out T> { 
    void M(T t); 
} 

在第一，T是唯一通过出来的东西。在第二个，它通过在。

在第一种情况下，我们不能使用协方差来引入类型空洞。我们有一个I<Cat>，我们将它转​​换为I<Animal>，现在M返回一个Animal，但没关系，因为我们已经知道它会返回Cat，并且Cat是Animal。

但在第二种情况下，我们有相反的情况。如果我们允许I<Cat>转换为I<Animal>，那么我们有一个M，它可以采取Turtle，但真正的实现只能处理Cat s。这就是为什么C＃会使这非法。

因此，请继续使用协变，但请记住您必须向编译器证明您需要它，并且在任何情况下它都是安全的。如果你不想要它，或者它不安全，那么你就不会有协变，你必须为你的问题找到一个不同的解决方案。