C# 当类型为动态且两个变量都是相同基类的导数时，检查两个变量是否相同

是否可以检查列表是否包含给定（但动态）类型的对象，该对象来自相同的基本抽象类

主要问题不在于列表，而在于比较类型本身。 在单变量和静态变量中，很容易：

if(someVariable is int)

使用静态类型检查列表也很容易，例如：

SomeList.OfType<int>().Any()

SomeList.OfType（）.Any（）

或

（来自SomeList.of类型中的_Object，其中_Object为int select _Object）。Count（）==0

但如果我要检查的类型是动态的，即作为方法参数传递，我无法处理它：

abstract class BasicClass;
class DerivativeOne : BasicClass { }
class DerivativeTwo : BasicClass { }

// in main:

List<BasicClass> _List = new List<BasicClass>();
DerivativeOne a = new DerivativeOne();
DerivativeTwo b = new DerivativeTwo();
DerivativeOne c = new DerivativeOne();

if(!CheckIfTypeExistsInList(a, _List)
{
    _List.Add(a);
}
if(!CheckIfTypeExistsInList(b, _List)
{
    _List.Add(b);
}
if(!CheckIfTypeExistsInList(c, _List)
{
    _List.Add(c);  // this is what I don't want to happen,
           // because I already have one object of type DerivativeOne in my list.
}


// the function:
bool CheckIfTypeExistsInList(BasicClass pObject, List<BasicClass> pList)
{
    /// few attempts:
    pList.OfType<(pObject.GetType()>().Any();  // attempt one, error
    return  (from _Object in SomeList.OfType<(pObject.GetType())> where _Object is int select _Object).Count() == 0;    // attempt two, error
}

抽象类基本类；
类派生One:BasicClass{}
类派生对象：基本类{}
//大体上：
列表_List=新列表（）；
衍生工具a=新衍生工具（）；
DerivativeTwo b=新的DerivativeTwo（）；
衍生工具c=新的衍生工具（）；
如果（！CheckIfTypeExistsInList（a，\U列表）
{
_列表.添加（a）；
}
如果（！CheckIfTypeExistsInList（b，_列表）
{
_列表.添加（b）；
}
如果（！CheckIfTypeExistsInList（c，_List）
{
_List.Add（c）；//这是我不想发生的事情，
//因为我的列表中已经有一个类型为DerivationOne的对象。
}
//职能：
bool CheckIfTypeExistsInList（基本类pObject，列表pList）
{
///几次尝试：
pList.OfType（）.Any（）；//尝试一次，错误
返回（来自SomeList.of类型中的_对象，其中_对象为int select _对象）。Count（）==0；//尝试两次，错误
}

另外，我知道代码看起来并不整洁，但我试图显示问题本身，跳过了额外的逻辑和东西

---

PS2.我知道解决这个问题的方法就是给BasicClass添加一些属性，并使每个派生都具有唯一的属性值，但是-我并不是在寻找另一条解决问题的途径，我只是想知道是否有可能做到“这一点”方法。

当类型仅在运行时已知时，如果不使用反射，则无法在泛型中使用它。但是，您的任务比这更简单-您可以使用类型相等来实现所需的结果：

Type targetType = pObject.GetType();
if (SomeList.Any(o => targetType.Equals(o.GetType()))) {
    ...
}

---

泛型是一个编译时的东西，你不能像我肯定你发现的那样在中放入运行时值。我已经尝试过这种方法，但不幸的是它不起作用……我认为问题是这两个变量都是同一类的派生，所以IsAssignableFrom不能完成它的工作。@KamilT如果

targetType

是

o

的基类型>的类型，则表达式的计算结果为

true

。能否显示这两种类型的类型层次结构及其基础，并告诉您希望将哪些组合计算为

true

，哪些组合计算为

false

？（抱歉，很难格式化注释，因此可读性不强……）在我的问题中显示了层次结构，我希望得到的结果是f.e.：typeof-DerivativeOne==typeof-DerivativeOne->true，typeof-DerivativeOne==typeof-DerivativeTwo->false，typeof-DerivativeOne==typeof-BasicClass->false@KamilT然后您可以使用类型相等而不是

是可从

中指定的。

Type targetType = pObject.GetType();
if (SomeList.Any(o => targetType.Equals(o.GetType()))) {
    ...
}