Question

我对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();

        ...
      }
  }

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

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

感谢您的帮助。

Answer 1

您正在寻找多态行为。

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();
    }
}

您通常不希望在方法内部进行类型检查，因为您似乎已经意识到了这一点。它不是特别关于效率，因为它是关于良好的编程实践。每次添加新类时，都必须返回该方法并添加另一项检查，这违反了各种实体编程实践。

Answer 2

为您的类型实施一些界面

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();
      }
  }

Answer 3

public interface IDoSomething
{
    void DoSomething();
}

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

如何通过泛型方法从对象中调用函数？

3 个答案: