C#将类添加到泛型列表中，然后检索类型

我有以下课程：

class A {
}
class B {
}
class C {
}

我将它们添加到列表中：

List<object> ListOfClasses = new List<object>();
ListOfClasses.Add(new A());
ListOfClasses.Add(new B());
ListOfClasses.Add(new C());
processClasses(ListOfClasses);

ListOfClasses=newlist（）；
添加（新的A（））；
添加（新的B（））；
添加（新的C（））；
processClasses（类列表）；

现在我想不出的部分是：

processClasses(List<object> myClasses) {
   foreach(object obj in myClasses) {

   doSomeWork(obj.GetType(), new OtherWork<the class of obj>());

   }
    }

processClasses（列出myClasses）{
foreach（MyClass中的对象对象对象）{
doSomeWork（obj.GetType（），new OtherWork（））；
}
}

什么应该作为MoreWork的参数化类型。如果我一次只上一节课，那么我会做如下事情：

doSomeWork(typeof(A), new OtherWork<A>());

doSomeWork（类型为（A），新的其他工作
processClasses（列出我的类）
{
foreach（myClasses.OfType（）中的对象）{
doSomeWork（A.GetType（），newotherwork（））；
}
foreach（myClasses.OfType（）中的B obj）{
doSomeWork（B.GetType（），newotherwork（））；
}
foreach（myClasses.OfType（）中的C obj）{
doSomeWork（C.GetType（），newotherwork（））；
}
}
无法执行此操作的原因是编译器需要提前知道使用的类型
OtherWork
，以便为这些类型生成类

不过，您可以在运行时执行此操作。稍后将使用编译。但是，这可能不是正确的模式

（从上一次编辑中）当然还有更多的类需要处理。其他工作基本上是这里的ColumnAttributeTypeMapper：

如果这是您唯一的限制，那么最简单的事情就是创建一个新的
ColumnAttributeTypeMapper
实现，该实现不是泛型的，而是使用类型参数

public class ColumnAttributeTypeMapper : FallbackTypeMapper
{
    public ColumnAttributeTypeMapper(object instance)
        : this (instance.GetType())
    {
    }
    public ColumnAttributeTypeMapper(Type T)
        : base(new SqlMapper.ITypeMap[]
            {
                new CustomPropertyTypeMap(
                   T,
                   (type, columnName) =>
                       type.GetProperties().FirstOrDefault(prop =>
                           prop.GetCustomAttributes(false)
                               .OfType<ColumnAttribute>()
                               .Any(attr => attr.Name == columnName)
                           )
                   ),
                new DefaultTypeMap(T)
            })
    {
    }
}

公共类ColumnAttributeTypeMapper:FallbackTypeMapper
{
公共列AttributeTypeMapper（对象实例）
：此（instance.GetType（））
{
}
公共列AttributeTypeMapper（T型）
：base（新的SqlMapper.ITypeMap[]
{
新CustomPropertyTypeMap(
T
（类型、列名称）=>
type.GetProperties（）.FirstOrDefault（prop=>
prop.GetCustomAttributes（false）
第（）类
.Any（attr=>attr.Name==columnName）
)
),
新的DefaultTypeMap（T）
})
{
}
}
您几乎肯定首先要避免这样做。请确保所有类都有一个公共的基类型（或接口）我理解，但这些类实际上并没有太多的共同数据，只是它们需要以类似的方式进行处理。它们共同拥有的数据可能是不相关的。重要的是它们都需要拥有的操作。与这些操作建立一个接口，你能举个例子说明它们是如何处理的吗？这听起来像是@Servy提到的接口的例子。如果它们没有共同点，那么这个例子（对我来说）就没有意义了。也许你可以将你的更多工作和其他工作的例子扩展得更具体，以说明你试图解决的问题？无论哪种方式，接口都可能是你想要的方式（我说可能是因为我不是100%清楚你想要实现什么）现在，当一个
D
被添加到列表中，或者一个
Z
中时，代码就会中断。如果只提供这三种类型是有意义的，那么首先就不应该有一个列表，应该有三个列表，三种类型中的每一种。@Servy-这是“中断”这个词的一个非常宽泛的用法。这些代码被“设计”为不与其他类型一起工作。然后，正如我所描述的那样，实际上将其设计为不与任何其他类型一起工作，而不是编写一个表示它将对任何类型工作的方法，但实际上不这样做。创建与做事情成比例的方法，然后又无法做这些事情，实际上是“失败的”@Servy我认为使用这个模型可以很容易地创建感兴趣类型的外部循环。这是为了说明OfType（）是如何工作的（这确实是他的问题）。
public class ColumnAttributeTypeMapper : FallbackTypeMapper
{
    public ColumnAttributeTypeMapper(object instance)
        : this (instance.GetType())
    {
    }
    public ColumnAttributeTypeMapper(Type T)
        : base(new SqlMapper.ITypeMap[]
            {
                new CustomPropertyTypeMap(
                   T,
                   (type, columnName) =>
                       type.GetProperties().FirstOrDefault(prop =>
                           prop.GetCustomAttributes(false)
                               .OfType<ColumnAttribute>()
                               .Any(attr => attr.Name == columnName)
                           )
                   ),
                new DefaultTypeMap(T)
            })
    {
    }
}