C# 4.0 中的双重调度 - 动态关键字？

Question

我知道以前有人问过这个问题，但我没有就最佳解决方案达成明确的一致意见。

使用动态（如下所示）是最好的方法吗？ 我想最好尽可能避免动态，以帮助在编译时发现问题。

（classA1 和 classA2 实现接口 A，B 也一样）

 public static void Foo(InterfaceA a, InterfaceB b) 
 { 
    Foo((dynamic)a, (dynamic)b); 
 }

static void Foo(classA1 a, classB1 b) {  //some code }
static void Foo(classA2 a, classB2 b) {  //some code }
static void Foo(classA1 a, classB2 b) {  //some code }
static void Foo(classA2 a, classB1 b) {  //some code }

或者类似的......

public static void Foo(InterfaceA a, InterfaceB b) 
 { 
    ((dynamic) a).Foo(b); 
 }

public classA1
{
     void Foo(classB1 b) {  //some code }
}
//repeated for other cases    

Answer 1

使用动态（如下所示）是最好的方法吗？

嗯，这是一种的方法——只要执行时类型总是以重载决议会满意的东西结束。

你可能想放一个支持方法

static void Foo(object x, object y)

如果这些方法都不适用（例如，a 是非 ClassA1/ClassA2 实现）。如果两个值都为空，这对您没有帮助，请注意...

我通常会尝试重新设计，这样就不需要了，但是如果没有更多的上下文，很难知道最佳解决方案。

Answer 2

'classA1' 等是InterfaceA 的实现吗？如果是这样，那么为什么不将Foo 函数声明为接受InterfaceA 和InterfaceB 并将它们转换为函数期望的具体实现呢？例如，

static void Foo(InterfaceA a, InterfaceB b) {
    classA1 c1 = a as classA1;
    classB1 b1 = b as classB1;
    // ... etc
}

Dynamic 不适合以这种方式使用。

Answer 3

你可以用反射来做一些糟糕的事情——但我相信它并不比做动态更好：

void Main()
{
    var a = "hello";//5;
    var b = "hello"; 

    var type1 = a.GetType();
    var type2 = b.GetType();

    var t = typeof(FooClass);

    var methods = t.GetMethods();

    foreach(var method in methods)
    {
        var parameters = method.GetParameters();

        if(parameters.Length == 2)
        {
            if(parameters[0].ParameterType == type1 
               && parameters[1].ParameterType == type2)
            {
                method.Invoke(this, new object[]{ a, b });
            }
        }
    }
}

public static class FooClass
{
    public static void Foo(int i, string s)
    {
        "Foo1".Dump();
    }

    public static void Foo(string s, string s2)
    {
        "Foo2".Dump();
    }
}

Answer 4

C# 传统上是一种静态类型的语言。动态关键字adds dynamic typing to the language。通常的建议是使用“动态”sparingly。这里可能是您需要它的情况。

Generics 不会删掉它，因为这不会编译：

    private void button1_Click(object sender, EventArgs e)
    {
        Foo(new classA1(), new classB2());
    }

    static void Foo<T, T1>(T a, T1 b) where T: InterfaceA
        where T1: InterfaceB
    {
        Foo2(a, b);
    }

    static void Foo2(classA1 a, classB1 b) { }
    static void Foo2(classA2 a, classB2 b) { }
    static void Foo2(classA1 a, classB2 b) { }
    static void Foo2(classA2 a, classB1 b) { }

    interface InterfaceA { }
    interface InterfaceB { }

    class classA1 : InterfaceA { }
    class classA2 : InterfaceA { }

    class classB1 : InterfaceB { }
    class classB2 : InterfaceB { }