C# 无法将派生类对象添加到其列表中'；s基类类型

我的班级结构如下：

//BaseClass
public abstract class BaseClass<T> where T : Model
{
    public abstract T Data { get; set; }
    public BaseClass(T data) { Data = data; }
}

public abstract class Model
{
    public int Id { get; set; }
}

//ClassA
public class BaseClassA : BaseClass<ModelA>
{
    public override ModelA Data { get; set; }
    public BaseClassA(ModelA data) : base(data) { }
}

public class ModelA : Model { }

//ClassB
public class BaseClassB : BaseClass<ModelB>
{
    public override ModelB Data { get; set; }
    public BaseClassB(ModelB data) : base(data) { }
}

public class ModelB : Model { }

//基类
公共抽象类基类，其中T:Model
{
公共抽象T数据{get；set；}
公共基类（T data）{data=data；}
}
公共抽象类模型
{
公共int Id{get；set；}
}
//甲级
公共类BaseClassA：基类
{
公共重写ModelA数据{get；set；}
公共BaseClassA（ModelA数据）：数据库（数据）{}
}
公共类ModelA:Model{}
//B类
公共类BaseClassB：基类
{
公共重写ModelB数据{get；set；}
公共BaseClassB（ModelB数据）：数据库（数据）{}
}
公共类ModelB:模型{}

我想使用它们如下：

List<BaseClass<Model>> myBaseList = new List<BaseClass<Model>>();
myBaseList.Add(new BaseClassA(new ModelA()));
myBaseList.Add(new BaseClassB(new ModelB()));

foreach (var item in myBaseList)
{
    if (item.Data.Id > 0)
    {
        //do stuff
    }
}

List myBaseList=newlist（）；
添加（新的BaseClassA（新的ModelA（））；
添加（新的BaseClassB（新的ModelB（））；
foreach（myBaseList中的变量项）
{
如果（item.Data.Id>0）
{
//做事
}
}

但我得到了编译器异常：

无法从BaseClassA转换为BaseClass

然而，我得到的印象是，BaseClass类型的BaseClassA将满足BaseClass类型的要求

例如，这不会产生任何错误：

List<Model> myModelList = new List<Model>();
myModelList.Add(new ModelA());
myModelList.Add(new ModelB());

List myModelList=new List（）；
添加（newmodela（））；
添加（新模型b（））；

---

我似乎无法理解我在这方面的错误所在。

一个可能的解决方案是引入协变接口：

public interface IBase<out T> where T : Model
{
    T Data { get; }
}

public abstract class BaseClass<T> : IBase<T> where T : Model

---

一种可能的解决方案是引入协变接口：

public interface IBase<out T> where T : Model
{
    T Data { get; }
}

public abstract class BaseClass<T> : IBase<T> where T : Model

---

BaseClass

对于

T

是不变的，因此

BaseClass

不是

BaseClass

的子类。如果允许这样做，我将能够执行

myModelList[0]。Data=newModelB（）！请注意，
myModelList[0]
实际上包含一个
BaseClassA
。现在这没有意义了，是吗？@Sweeper谢谢你，这很有意义如果目的是创建两个派生类的列表，而不是创建一个抽象基类，那么创建一个具有类似结构的接口。
BaseClass
对于
t
是不变的，因此
BaseClass
不是
BaseClass
的子类。如果允许，我将能够执行
myModelList[0]。Data=new ModelB（）！请注意，
myModelList[0]
实际上包含一个
BaseClassA
。现在这没有意义了，是吗？@Sweeper谢谢你，这很有意义如果目的是创建两个派生类的列表，而不是创建一个抽象基类，那么创建一个具有类似结构的接口。
foreach (var item in myBaseList)
{
    if (item.Data.Id > 0)
    {
        //do stuff
    }
}