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>'.

有人可以解释为什么这不起作用吗？

Answer 1

让我们简化：

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>();

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

现在我已经重写了代码以简化它，应该很清楚。 ICage<IAnimal>是一个笼子，你可以放置任何动物，但Cage<Tiger> 只能容纳老虎，所以这必须是非法。

如果它不违法，那么你可以这样做：

cage.Enclose(new Fish());

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

类型系统不允许进行转换，因为这样做会违反源类型的功能不得的规则，而不是目标类型的功能。（这是着名的“Liskov替代原则”的一种形式。）

更具体地说，我会说你滥用泛型。事实上，你做的类型关系太复杂了，你无法分析自己，这证明你应该简化整个事情;如果你没有保持所有的类型关系并且你写了这个东西那么你的用户肯定也无法保持直接。

Answer 2

Eric已经有了一个非常好的答案。只是想利用这个机会在这里讨论不变性，协方差和 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();

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

Answer 3

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

class MyAppointment : Appointment<IAppointmentProperties> {
}

现在转换可以隐式发生。

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

Answer 4

如果从以下位置重新定义样本接口，它将起作用：

interface ICage<T>

到

interface ICage<out T>

（请注意out关键字）

然后以下陈述是正确的：

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

Answer 5

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

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

5 个答案: