C# 问题与「；其中；在泛型继承中

在以下代码中，

entities=doSpecialStuff（entities）行出现问题因为我的
doSpecialStuff（）
Methode的where部分“缺少”了一些东西

错误

类型“T”不能用作泛型类型或方法中的类型参数“T”

'myWorkClass.doSpecialStuff（IEnumerable实体）'。没有隐含的
从'T'到'ISpezial'的引用转换。）

代码
这是我的惯性结构

public class Baseclass { }

public interface ISpezial 
{ 
    int mySpecial{get;set;} 
}

public class Class1 : Baseclass { }

public class Class2 : Baseclass, ISpezial
{
    public int mySpecial{ get;set;}
}

这是我的数据提供者

public class myRepository
{
    public static IEnumerable<TResult> Load<TResult>() where TResult : Baseclass, new()
    {
        List<TResult> myEnum = new List<TResult>();

        if (typeof(ISpezial).IsAssignableFrom(typeof(TResult)))
        {
            myEnum.Add((new Class2() { mySpecial = 0 }) as TResult);
            myEnum.Add((new Class2() { mySpecial = 1 }) as TResult);
            myEnum.Add((new Class2() { mySpecial = 2 }) as TResult);
        }
        else
        {
            myEnum.Add((new Class1() as TResult));
            myEnum.Add((new Class1() as TResult));
            myEnum.Add((new Class1() as TResult));
        }

        return myEnum;
    }
}

公共类myRepository
{
公共静态IEnumerable Load（），其中TResult:Baseclass，new（）
{
List myEnum=new List（）；
if（typeof（ISpezial）.IsAssignableFrom（typeof（TResult）））
{
添加（（新类2（）{mySpecial=0}）作为TResult）；
添加（（新类2（）{mySpecial=1}）作为TResult）；
添加（（新类2（）{mySpecial=2}）作为TResult）；
}
其他的
{
Add（（新的Class1（）作为TResult））；
Add（（新的Class1（）作为TResult））；
Add（（新的Class1（）作为TResult））；
}
回髓；
}
}

在那里，是一个像老板一样做事情并提供错误的类

public class myWorkClass<T> where T : Baseclass, new()
{
    public void doNormalStuff()
    {
        var entities = myRepository.Load<T>();
        if (typeof(ISpezial).IsAssignableFrom(typeof(T)))
        {
            entities = doSpecialStuff(entities);
        }
    }

    public IEnumerable<T> doSpecialStuff<T>(IEnumerable<T> entities) where T : ISpezial
    {
        var list = new List<T>();

        return list.Where(special => special.mySpecial==2);
    }
}

公共类myWorkClass，其中T:Baseclass，new（）
{
公共void doNormalStuff（）
{
var entities=myRepository.Load（）；
if（typeof（ISpezial）.IsAssignableFrom（typeof（T）））
{
实体=doSpecialStuff（实体）；
}
}
公共IEnumerable DosSpecialStuff（IEnumerable实体），其中T:ISpezial
{
var list=新列表（）；
返回列表。其中（special=>special.mySpecial==2）；
}
}

还有一个问题
如何避免我的where's中的
new（）

如何将Add部分
myRepository
更改为do
myEnum.Add（new Class1（））
而不是
myEnum.Add（（新的Class1（）作为TResult））
在不更改返回值的情况下
IEnumerable
？
由于T（基类或基类的子类）之间没有隐式转换，因此仅检查ISpezial是否可赋值是不够的（您可以这样做，而且非常好），在将其作为参数传递时还需要显式地强制转换变量，然后把它扔回去。不过，这并不是最好的课堂设计

 entities = doSpecialStuff(entities.Cast<ISpezial>()).Cast<T>();

entities=doSpecialStuff（entities.Cast（））.Cast（）；

第二个问题：由于显式调用Class2（）和Class1（）构造函数，因此实际上并不依赖于C#的多态性/泛型类型，这就是为什么存在new（）约束（例如，如果编写了new T（））。因此，只要代码保持这样，就可以删除约束

第三：您可以使用dynamics关键字，创建动态类型列表，并仅在最后一刻强制执行：

List<dynamic> myEnum = new List<dynamic>();
//your code
myEnum.Add((new Class2() { mySpecial = 0 })); //it's ok to write like you want it now
//your code
return myEnum.Cast<TResult>();

List myEnum=new List（）；
//你的代码
Add（（新类2（）{mySpecial=0}））//现在就可以随心所欲地写了
//你的代码
返回myEnum.Cast（）；
一点也不-除非你正在处理数以百万计的对象，否则你会损失几分之一秒的时间。编辑（之前的链接错误）：使用10000000个对象测试一点后查看ok同意您的观点：D+1是实用的，并且实际测试了它。保持下去：D