C# 多个调度选项

class Asset
{    }
class House:Asset
{    }

static void Foo (Asset a) { }
static void Foo (House h) { }

House h = new House (...); 
Foo(h);

Asset a = new House (...);
Foo(a); 

 Asset a = new House (...);
 Foo ((dynamic)a); // NOW it will call  Foo(House)

目标：访问运行时类型方法

这就是dynamic关键字的用途。这实际上是一种非常干净和快速的方式来进行多次调度。

您的多重派送的最终选择是

1. dynamic
2. 双重调度虚拟方法
3. 一些哈希匿名函数规则集合
4. if (x is House) ... else if(x is Asset)...
5. 反思——非常缓慢和丑陋

问题：有没有其他方法可以做到这一点(无需将函数移动到多态机制||动态(？

所以是的，有一些方法可以让你做很多工作，当你可以使用dynamic快速、不易出错且语法非常干净时。

如果你想要静态入口点，但又想要多态行为，那么最简单的混合是使用单例模式。 它将为您提供静态入口点，并且它返回的对象将具有多态方法。

我还建议忽略所有说单身人士是一件可怕的坏事的人。 Prima Donna Singleton悲惨的说教是中级开发人员的垃圾。 单例只是一个工具，如果它符合您的需求 - 那就使用它。

我认为这就是Foo((dynamic)a)幕下发生的事情：

Asset a = new House();
Type t = typeof(MainClass);
t.InvokeMember("Foo", 
     System.Reflection.BindingFlags.InvokeMethod, null, 
     t, new object[] { a });

这将解决Foo(House h)

---

快速访问monodis.exe，不使用反射(例如InvokeMember(，即使用动态关键字代替，Asset a = new House(); Foo((dynamic)a)，这是IL：

IL_0025:  ldstr "Foo"
IL_002a:  ldnull 
IL_002b:  ldtoken MainClass
IL_0030:  call class [mscorlib]System.Type class [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)

你的直觉会告诉你，"Foo"是一个死的赠品，动态是一种反思的业务。

现在，这是无动态的，即 Asset a = new House(); Foo(a) ：

IL_0010:  ldloc.0 
IL_0011:  call void class MainClass::Foo(class Asset)

烧毁的指令几乎已经决定了，不会改变，它总是决心Foo(Asset);

以下是可用于分析动态行为(通过 monodis.exe 或 ildasm.exe(的完整代码：

using System;
public class MainClass {
    public static void Main() {
        Console.WriteLine("Hei");
        Asset a = new House();        
        Foo(a);    
        Foo((dynamic)a);  
        object x = 7;
        Foo((dynamic)x);
    }
    public static void Foo(House h) { Console.WriteLine("House"); }
    public static void Foo(Asset a) { Console.WriteLine("Asset"); }
    public static void Foo(int i) { Console.WriteLine("int"); }
}

public class Asset {
}
public class House : Asset {
}

输出：

Hei
Asset
House
int

这将调用 Foo 重载 int，即 Foo(int i) ：

object x = 7;
t.InvokeMember("Foo", System.Reflection.BindingFlags.InvokeMethod, null, 
   t, new object[] { x } ); 

这也将：

t.InvokeMember("Foo", System.Reflection.BindingFlags.InvokeMethod, null, 
   t, new object[] { 8 } ); 

---

所以关于你的问题，你可以使用什么其他选项，你可以使用一个接受非类型化对象的方法：

public static void FooDynamic(object o) 
{
    Type t = typeof(MainClass);
    t.InvokeMember("Foo", System.Reflection.BindingFlags.InvokeMethod, null, t, new object[] { o } ); 
}

要调用：

Asset a = new House();
FooDynamic(a); // will select Foo House overload 
int i = 7;
FooDynamic(i); // will select Foo int overload

你也可以把这个 API 用于上面的代码：public static void Foo(object o)，那么你将不得不像这样调用 Foo：

Asset a = new House();
Foo((object)a); // will resolve to House

鉴于 C# 4 中已经有dynamic功能，除非开发人员仍在使用 C# 3，否则我很难使用反射。所以在那里，使用动态方法代替：-(

---

更新

值得一提的是，dynamic很慢(至少在 Mono 上(，当我运行这段代码时，在字母"B"出现之前有相当长的延迟，大约 2 秒。即使我交换动态和反射的代码顺序，动态的延迟也是可重现的。反射的延迟是难以察觉的，它比动态更快。

using System;
public class MainClass {
    public static void Main() {
        // there's a delay on initial dynamic call, about two seconds
        Test (); 
        Console.ReadLine ();
        // dynamic's speed is instant on subsequent calls, 
        // as clarified by Eric Lippert, the delegate is cached,
        // hence the elimination of delay on subsequent dynamic calls
        Test (); 
    }
    public static void Test() {
        Asset a = new House();
        Console.WriteLine("A");
        Foo((dynamic)a);  // there is a considerable delay here, the "B" string appears after two seconds
        Console.WriteLine ("B");        
        Type t = typeof(MainClass);
        t.InvokeMember("Foo", System.Reflection.BindingFlags.InvokeMethod, null, t, new object[] { a } ); 
        Console.WriteLine("C");
    }

    public static void Foo(House h) { Console.WriteLine("House"); }
    public static void Foo(Asset a) { Console.WriteLine("Asset"); }
    public static void Foo(int i) { Console.WriteLine("int"); }
}

public class Asset {
}
public class House : Asset {
}