我创建了几个用于处理议程约会的接口和泛型类：
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>'.
任何人都可以解释为什么这不起作用？
让我们简化一下：
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替代原则”的一种形式。）
更具体地说，我会说你滥用泛型。事实上，你做的类型关系太复杂了，你无法分析自己，这证明你应该简化整个事情;如果你没有保持所有的类型关系并且你写了这个东西，那么你的用户肯定也无法保持直线。
埃里克已经有了一个非常好的答案。只想借此机会在这里讨论不变性，协方差和逆变性。
有关定义，请参阅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();
从团队的角度来看，里面的东西并不重要，他们只是从容器中卸下动物。
因为您使用具体类型而不是接口声明了MyAppointment类。你应该声明如下：
class MyAppointment : Appointment<IAppointmentProperties> {
}
现在转换可以隐式发生。
通过使用约束AppointmentEntry<T>声明where T: IAppointment<IAppointmentProperties>，您创建了一个契约，其中AppointmentEntry<T>的未指定类型必须适应使用IAppointmentProperties声明的任何类型。通过声明具有类具体的类型，您违反了该合同（它实现了一种IAppointmentProperties但不是任何类型）。
如果您从以下位置重新定义示例界面，它将起作用：
interface ICage<T>
至
interface ICage<out T>
（请注意out关键字）
那么以下陈述是正确的：
ICage<IAnimal> cage = new Cage<Tiger>();
如果其他人也有这个错误消息：我发现在不同的命名空间中定义了两次相同的接口，并且尝试链接在一起的类没有使用相同的接口。