C# 如何从泛型方法得到的对象调用函数？

我对C#比较陌生，所以请容忍我

我不知道如何更有效地执行此操作

public static void Foo<T>(LinkedList<T> list)
{
    foreach (Object o in list)
    {
        if (typeof(o) == typeof(MyClass1))
            (MyClass1)o.DoSomething();
        else if (typeof(o) == typeof(MyClass2))
            (MyClass2)o.DoSomething();

        ...
      }
  }

publicstaticvoidfoo（LinkedList列表）
{
foreach（列表中的对象o）
{
if（typeof（o）=typeof（MyClass1））
（MyClass1）o.DoSomething（）；
else if（typeof（o）=typeof（MyClass2））
（MyClass2）o.DoSomething（）；
...
}
}

我想做这样的事情，或者比我现在做的更有效率的事情。我所说的高效是指程序运行得更快

public static void Foo<T>(LinkedList<T> list)
{
    foreach (Object o in list)
    {
        o.DoSomething();
      }
  }

publicstaticvoidfoo（LinkedList列表）
{
foreach（列表中的对象o）
{
o、 DoSomething（）；
}
}

---

谢谢您的帮助。

您正在寻找多态行为

abstract class Base // could also simply be interface, such as ICanDoSomething
{
     public abstract void DoSomething();
}

class MyClass1 : Base
{
    public override void DoSomething() { /* implement */ }
}

在这种情况下，可以将方法定义为将

T

约束到

Base

，然后允许使用针对

Base

定义但由每个派生类实现的方法

public static void Foo<T>(LinkedList<T> list) where T : Base // or T : ICanDoSomething
{    
    foreach (T item in list)
    {
         item.DoSomething();
    }
}

publicstaticvoidfoo（LinkedList列表），其中T:Base//或T:ICanDoSomething
{    
foreach（列表中的T项）
{
项目.DoSomething（）；
}
}

---

您通常不希望求助于方法内部的类型检查，正如您似乎已经意识到的那样。这并不特别关乎效率，而是关乎良好的编程实践。每次添加新类时，都必须返回该方法并添加另一个检查，这违反了所有可靠的编程实践。

您正在寻找多态行为

abstract class Base // could also simply be interface, such as ICanDoSomething
{
     public abstract void DoSomething();
}

class MyClass1 : Base
{
    public override void DoSomething() { /* implement */ }
}

在这种情况下，可以将方法定义为将

T

约束到

Base

，然后允许使用针对

Base

定义但由每个派生类实现的方法

public static void Foo<T>(LinkedList<T> list) where T : Base // or T : ICanDoSomething
{    
    foreach (T item in list)
    {
         item.DoSomething();
    }
}

publicstaticvoidfoo（LinkedList列表），其中T:Base//或T:ICanDoSomething
{    
foreach（列表中的T项）
{
项目.DoSomething（）；
}
}

---

您通常不希望求助于方法内部的类型检查，正如您似乎已经意识到的那样。这并不特别关乎效率，而是关乎良好的编程实践。每次添加新类时，都必须返回到方法并添加另一个检查，这违反了所有可靠的编程实践。

为您的类型实现一些接口

public interface IMyType
{
    void DoSomething();
}

public class MyType1 : IMyType
{
    public void DoSomething() { }
}

public class MyType2 : IMyType
{
    public void DoSomething() { }
}

和使用一样

public static void Foo<T>(LinkedList<T> list) where T: IMyType
{
    foreach (T o in list)
    {
        o.DoSomething();
      }
  }

publicstaticvoidfoo（LinkedList列表），其中T:IMyType
{
foreach（列表中的TO）
{
o、 DoSomething（）；
}
}

为您的类型实现一些接口

public interface IMyType
{
    void DoSomething();
}

public class MyType1 : IMyType
{
    public void DoSomething() { }
}

public class MyType2 : IMyType
{
    public void DoSomething() { }
}

和使用一样

public static void Foo<T>(LinkedList<T> list) where T: IMyType
{
    foreach (T o in list)
    {
        o.DoSomething();
      }
  }

publicstaticvoidfoo（LinkedList列表），其中T:IMyType
{
foreach（列表中的TO）
{
o、 DoSomething（）；
}
}

公共接口
{
无效剂量（）；
}
公共静态void Foo（LinkedList列表），其中T:ido
{
foreach（列表中的TO）
{
o、 DoSomething（）；
}
}

公共接口
{
无效剂量（）；
}
公共静态void Foo（LinkedList列表），其中T:ido
{
foreach（列表中的TO）
{
o、 DoSomething（）；
}
}

是否需要以相同的顺序调用项目？你见过类型的

吗？顺便说一句
类型的
是编译时的事情。您需要检查
null
，然后使用
o.GetType（）
如果
T
是无约束的，那么您就不能调用它——它可以是任何类型。也许您需要类似于
where T:IMyInterface
，在这种情况下，您可以确保列表只能包含实现
IMyInterface
的对象。感谢大家的帮助和回答。是否需要按相同的顺序调用这些项？你见过类型的
吗？顺便说一句
类型的
是编译时的事情。您需要检查
null
，然后使用
o.GetType（）
如果
T
是无约束的，那么您就不能调用它——它可以是任何类型。也许您需要类似于
where T:IMyInterface
，在这种情况下，您可以确保列表中只能包含实现
IMyInterface
的对象。感谢大家的帮助和回答。