c# - 为什么泛型类型约束会导致无隐式引用转换错误？

Question

我创建了几个接口和通用类来处理议程约会：

interface IAppointment<T> where T : IAppointmentProperties
{
    T Properties { get; set; }
}

interface IAppointmentEntry<T> where T : IAppointment<IAppointmentProperties>
{
    DateTime Date { get; set; }
    T Appointment { get; set; }
}

interface IAppointmentProperties 
{
    string Description { get; set; }
}

class Appointment<T> : IAppointment<T> where T : IAppointmentProperties
{
    public T Properties { get; set; }
}

class AppointmentEntry<T> : IAppointmentEntry<T> where T : IAppointment<IAppointmentProperties>
{
    public DateTime Date { get; set; }
    public T Appointment { get; set; }
}

class AppointmentProperties : IAppointmentProperties
{
    public string Description { get; set; }
}

我正在尝试对类型参数使用一些约束来确保只能指定有效类型。但是，当指定T必须实现的约束定义时IAppointment<IAppointmentProperties>，编译器在使用以下类时会出错Appointment<AppointmentProperties>：

class MyAppointment : Appointment<MyAppointmentProperties>
{
}

// This goes wrong:
class MyAppointmentEntry : AppointmentEntry<MyAppointment>
{
}

class MyAppointmentProperties : AppointmentProperties
{
    public string ExtraInformation { get; set; }
}

错误是：

The type 'Example.MyAppointment' cannot be used as type parameter 'T' in the generic type or method 'Example.AppointmentEntry<T>'. There is no implicit reference conversion from 'Example.MyAppointment' to 'Example.IAppointment<Example.IAppointmentProperties>'.

谁能解释为什么这不起作用？

score 148 · Accepted Answer

让我们简化一下：

interface IAnimal { ... }
interface ICage<T> where T : IAnimal { void Enclose(T animal); } 
class Tiger : IAnimal { ... }
class Fish : IAnimal { ... }
class Cage<T>  : ICage<T> where T : IAnimal { ... }
ICage<IAnimal> cage = new Cage<Tiger>();

你的问题是：为什么最后一行是非法的？

现在我已经重写了代码来简化它，应该很清楚了。 AnICage<IAnimal>是一个笼子，你可以放任何动物，但aCage<Tiger>只能关老虎，所以这一定是违法的。

如果它不是非法的，那么你可以这样做：

cage.Enclose(new Fish());

嘿，你只是把一条鱼放进老虎笼子里。

类型系统不允许这种转换，因为这样做会违反源类型的能力不得小于目标类型的能力的规则。（这是著名的“里氏替换原则”的一种形式。）

更具体地说，我会说你在滥用泛型。你建立的类型关系太复杂以至于你无法分析自己，这一事实证明你应该简化整个事情。如果您没有保持所有类型关系的正确性并且您编写了内容，那么您的用户肯定也无法保持正确性。

score 23 · Accepted Answer

Eric 已经给出了很好的答案。只是想借此机会在这里谈谈Invariance，Covariance和Contravariance。

有关定义，请参阅https://docs.microsoft.com/en-us/dotnet/standard/generics/covariance-and-contravariance

假设有一个动物园。

abstract class Animal{}
abstract class Bird : Animal{}
abstract class Fish : Animal{}
class Dove : Bird{}
class Shark : Fish{}

动物园正在搬迁，所以它的动物需要从旧动物园搬到新动物园。

不变性

在我们移动它们之前，我们需要将动物放入不同的容器中。这些容器都执行相同的操作：将动物放入其中或从中取出动物。

interface IContainer<T> where T : Animal
{
    void Put(T t);
    T Get(int id);
}

显然，对于鱼，我们需要一个坦克：

class FishTank<T> : IContainer<T> where T : Fish
{
    public void Put(T t){}
    public T Get(int id){return default(T);}
}

所以鱼可以放入并从鱼缸中取出（希望还活着）：

IContainer<Fish> fishTank = new FishTank<Fish>(); //Invariance, the two types have to be the same
fishTank.Put(new Shark());          
var fish = fishTank.Get(8);

假设我们被允许将其更改为IContainer<Animal>，那么您可能会不小心将一只鸽子放入水箱中，这样就会发生悲剧。

IContainer<Animal> fishTank = new FishTank<Fish>(); //Wrong, some animal can be killed
fishTank.Put(new Shark());
fishTank.Put(new Dove()); //Dove will be killed

逆变

为了提高效率，动物园管理团队决定将加载和卸载过程分开（管理层总是这样做）。所以我们有两个独立的操作，一个仅用于加载，另一个用于卸载。

interface ILoad<in T> where T : Animal
{
    void Put(T t);
}

然后我们有一个鸟笼：

class BirdCage<T> : ILoad<T> where T : Bird
{
    public void Put(T t)
    {
    }
}

ILoad<Bird> normalCage = new BirdCage<Bird>();
normalCage.Put(new Dove()); //accepts any type of birds

ILoad<Dove> doveCage = new BirdCage<Bird>();//Contravariance, Bird is less specific then Dove
doveCage.Put(new Dove()); //only accepts doves

协方差

在新的动物园里，我们有一个卸载动物的团队。

interface IUnload<out T> where T : Animal
{
    IEnumerable<T> GetAll();
}

class UnloadTeam<T> : IUnload<T> where T : Animal
{
    public IEnumerable<T> GetAll()
    {
        return Enumerable.Empty<T>();
    }
}

IUnload<Animal> unloadTeam = new UnloadTeam<Bird>();//Covariance, since Bird is more specific then Animal
var animals = unloadTeam.GetAll();

从团队的角度来看，里面是什么并不重要，他们只是从容器中卸下动物。

score 7 · Accepted Answer

因为您MyAppointment使用具体类型而不是接口声明了您的类。你应该声明如下：

class MyAppointment : Appointment<IAppointmentProperties> {
}

现在转换可以隐式发生。

通过AppointmentEntry<T>使用约束声明，where T: IAppointment<IAppointmentProperties>您正在创建一个合同，其中未指定的类型AppointmentEntry<T> 必须适应任何使用 . 声明的类型IAppointmentProperties。通过使用具体类声明类型，您违反了该合同（它实现了一种类型IAppointmentProperties但不是任何类型）。

score 1 · Accepted Answer

万一其他人也有此错误消息：我发现在不同的命名空间中定义了两次相同的接口，并且尝试链接在一起的类没有使用相同的接口。

score 1 · Accepted Answer

如果您从以下位置重新定义示例界面，它将起作用：

interface ICage<T>

至

interface ICage<out T>

（请注意out关键字）

那么下面的说法是正确的：

ICage<IAnimal> cage = new Cage<Tiger>();

c# - 为什么泛型类型约束会导致无隐式引用转换错误？

5 回答 5

Related

Reference