Question

我现在对C＃感到困惑。

我有一堆类，比如A，B和C，它们都来自“Parent”类。我有一个函数，它接受类型为Parent的参数，并且根据调用它的对象是哪个子类，我希望它调用另一个方法。

目前，我正在考虑使用字典映射类型来代表委托，但这看起来很愚蠢，尽管我现在只能想出来。

问题在于，当我在函数中时，我只知道它是Parent类型，并且我可以使用GetType来获取我拥有的子类，这将允许字典。否则我可能会使用函数重载。

真正的类型转换似乎是最好的方法，允许我使用函数重载，这将更加冗长，但我不知道我该怎么做或者它是否会起作用。

任何推荐？

Answer 1

这些方法是否共享相同的签名？如果是这样，请将其作为父类中的虚拟（可能是抽象的）方法：

using System;

public abstract class Parent
{
    public abstract void DoSomething();
}

public class A : Parent
{
    public override void DoSomething()
    {
        Console.WriteLine("A.DoSomething()");
    }
}

public class B : Parent
{
    public override void DoSomething()
    {
        Console.WriteLine("B.DoSomething()");
    }
}

public class Test
{
    static void Main()
    {
        Parent a = new A();
        Parent b = new B();
        a.DoSomething();
        b.DoSomething();
    }
}

如果这不合适，那么double dispatch 可能适合，但我真的需要了解更多有关情况......可能会改变某些部分现有的设计会更好。

Answer 2

如果您无法向Parent添加虚拟方法，并在A，B和C中覆盖

，这似乎是访问者模式的完美用法

Answer 3

重载是正确的方法

public void DoWork(Parent obj)
{
   if(obj is A)
     Foo((A)obj);

   else if(obj is B)
     Foo((B)obj);

   else
    Foo(obj);
}

public void Foo(Parent obj)
{
  //Do something for parent
}

public void Foo(A obj)
{
  //Do something for A
}

public void Foo(B obj)
{
  //Do something for B
}

或者如果你不想为每种类型显式地转换对象，你可以使用这样的反射：

Bar methodObject = new Bar();
MethodInfo method = methodObject.GetType().GetMethod(
            "Foo", new Type[] { obj.GetType()});

method.Invoke(methodObject, new object[]{obj});

Answer 4

方法的名称是否不同？或者它是同一方法的不同实现？

如果方法的名称相同，则可以使用覆盖。此外，如果只有一个子方法，则父方法应标记为抽象。

编辑：代码......

public abstract class parentClass
{
    //...other stuff...
    protected abstract void doSomething(); //or use virtual instead of abstract and give the method a body
}

public class childClass : parentClass
{
    //...other stuff...
    protected override void doSomething()
    {
       //...do something
    }
}

C＃调用函数基于对象的子类型

4 个答案: