什么是单次调度和多次调度（与 .NET 相关）？

Question

它是否与重载相同，如果不是，您能否提供 C# 中每个问题的示例

我已经阅读了对 SO 中提出的类似问题的答复...我不明白发布到它的答复。

类似的问题此处

提出编辑：使用新的“动态” C# 4.0 中的关键字...这会使语言“多重调度”启用吗？

Answer 1

多重分派是重载的一种“形式”...

例如，C# 是单分派，因为如果仅根据一个参数（“this”指针）计算出要调用的方法。 当你有这样的事情时：

Base base= new Derived();
base.DoSomething();

即使你通过基指针调用方法 Derived.DoSomething 也会被调用。 现在，如果我们有以下内容：

class Derived : Base
{
  public override void Process(Stream stream);
  public override void Process(FileStream stream);
  public override void Process(MemoryStream stream);
}

我们这样做：

Stream stream= new MemoryStream(...);
Base b= new Derived();
b.Process(stream);

然后我们将从 Derived 调用 Process(Stream) 方法，就像 C# 对对象执行一次调度一样指针（b），然后使用编译时信息来决定调用哪个方法。 即使stream是一个MemoryStream，单个调度系统也会忽略这一点。

在多调度系统中，将查看对象指针（如在 C# 中）并且将检查参数的运行时类型。 在上面的示例中，由于stream实际上是MemoryStream，因此系统将调用Process(MemoryStream)方法。

Answer 2

C# 使用单一调度，其中包括重载方法。 当您拥有代码时，

stringBuilder.Append(parameter);

调度程序会查看 stringBuilder 类中定义的所有方法，并找到正确的方法。

对于多重分派示例，让我们看一下 Prolog（这是我能想到的第一个）。 您可以在序言中定义一个函数，如下所示：

func(Arg1, Arg2) :- ....body....

这不是在任何类内部定义的，而是在全局范围内定义的。 然后，您可以对任意两个参数调用 func(Arg1, Arg2) ，并且该函数将被调用。 如果你想要重载之类的东西，你必须验证函数内的参数类型，并多次定义它：

func(Arg1, Arg2) :- is_number(Arg1), is_string(Arg2), ....body....
func(Arg1, Arg2) :- is_string(Arg1), is_list(Arg2), ....body....
func(Arg1, Arg2) :- is_number(Arg1), is_list(Arg2), ....body....

然后，你要发送的任何两个参数类型都将被检查 - 这就是多重​​分派部分。

简而言之，单一调度仅查看第一个参数（在我们的第一个示例中为 stringBuilder）上定义的方法，然后解析正确的重载以使用其他参数进行调用。 多重分派具有在全局范围内定义的方法/函数，并在重载决策期间将所有参数视为相同。

我希望我已经说清楚了，这是一个非常困难的话题。

---

更新：我忘了提及，多重分派发生在运行时，而单分派发生在编译时。
更新#2：显然，这不是真的。

Answer 3

多重调度与方法重载有关，但又不一样。 前者是动态运行时决定，后者是静态编译时决定。 多重调度隐含着灵活性优势，但也会带来性能成本。

据我所知，一种语言可以支持其中之一，但不能同时支持两者，尽管两者都可以模拟（可以与访问者模拟多调度）。 C# 在编译时确定数据类型，因此不是多调度语言，因此无法提供示例。

（警告：我对此不是 100％）

---

附录：实际上维基百科有一个 文章 看起来相当详尽，哦，还有一个有用的 LISP 示例

Answer 4

在 OO 语言中，文本：

SomeType b;
a = b.Foo(c, d)

表示正在向对象 b 传递带有参数 c 和 d 的消息 Foo。
单一调度意味着该系统只有一个方面负责在运行时确定 Foo 方法（可能有很多方法中的哪一个）将被实际调用。

java、c# 和大多数其他 OO 语言使用的模型是，只有“b”的运行时类型才能“决定”实际的方法调用是什么。 因此，如果您有 SomeType 的两个实现，它们都提供了 Foo 的不同实现，那么使用哪个的决定仅基于此时 b 恰好属于哪种类型。 如果 Foo 有多个重载，那么使用哪个重载的决定是编译时决定，仅基于编译时知道 b、c 和 d 的类型。

这就是单次调度，单点选择是与 b 关联的类型系统。

Multiple Dispatch 将在运行时允许 b、c 和 d 的运行时类型决定调用哪个方法（这样的决定不可避免地会更加复杂）。

在一个更加动态的系统中，明确定义的类型的概念更加灵活（比如基于原型的系统，而不是您从 c++/java/C# 中了解的继承模型），那么调用什么方法的决定将完全取决于到实际实例 b、c 和 d。

Answer 5

单/多调度是一种运行时重载。 单一调度通常称为虚拟函数。 调用虚函数时具体调用的函数是根据对象的运行时类型决定的。 双重调度是同样的事情，扩展为使用两个对象 - 通常是 this 参数和第二个参数。 您可以使用访问者模式轻松实现此目的。 多重分派进一步将此概念扩展到更多参数，但在 C# 等语言中实现起来要困难得多（不是说它不能做到，只是很难）。 有些语言直接实现了这种能力。

例如，在 .NET 中，ToString() 函数是单次调度的一个示例

// Single dispatch
Object o = GetSomeObject(); // Return SomeType casted to Object.
o.ToString(); // Call SomeType::ToString instead of just Object::ToString

// Double dispatch (this version won't work in C#)
Shape s1 = GetSquare();
Shape s2 = GetCircle();
s1.Intersects(s2); // If C# supported double dispatch, this would call Square::Intersects(Circle) not Square::Intersects(Shape)

Answer 6

#include <iostream>

class Pet {
};

class Cat: public Pet {
};

class Dog: public Pet {
};

class Human {
};

class Man : public Human {
        public:
                void Kick(Cat& victim);
                void Kick(Dog& victim);
};

class Woman : public Human {
        public:
                void Kick(Cat& victim);
                void Kick(Dog& victim);
};

void Man::Kick(Cat& victim) {
        std::cout << "Meow!!!" << std::endl;
}

void Woman::Kick(Cat& victim) {
        std::cout << "I won't kick a cat" << std::endl;
}

void Man::Kick(Dog& victim) {
        std::cout << "I won't kick a dog" << std::endl;
}

void Woman::Kick(Dog& victim) {
        std::cout << "Woof!!!" << std::endl;
}

int main(int argc, char** argv) {
        Man kicker;
        Dog victim;
        Pet zoo[] = { victim };
        kicker.Kick(victim);
//      kicker.Kick(zoo[0]);   // No multimethods
        return 0;
}

目前，C++ 无法在运行时判断 Pet 实际上是 Cat 还是 Dog。

如果有某种方法可以在运行时执行此操作（以便上面的代码可以在注释行未注释的情况下进行编译），则可以说 C++ 支持多重分派或多方法。

Answer 7

在 c# 4.0 中，使用新的动态关键字启用了多种方法：

using System;
命名空间示例
{
类轮
{
公共无效RepairWhell（）{}
。

class Chassis
{
    public void RepairChassis() { }
}

class Engine
{
    public void RepairEngine() { }
}

class CarWorkshop
{
    public string Repair(Wheel value)
    {
        value.RepairWhell();
        return "wheel repaired";
    }
    public string Repair(Chassis value)
    {
        value.RepairChassis();
        return "chassis repaired";
    }
    public string Repair(Engine value)
    {
        value.RepairEngine();
        return "engine repaired";
    }
}

class Program
{
    static void Main(string[] args)
    {
        dynamic carWorkshop = new CarWorkshop();

        var whell = new Wheel();
        var chassis = new Chassis();
        var engine = new Engine();

        Console.WriteLine(carWorkshop.Repair(whell));
        Console.WriteLine(carWorkshop.Repair(chassis));
        Console.WriteLine(carWorkshop.Repair(engine));
        Console.ReadLine();
    }
}

在 C# 中动态

引入多方法，这是一个非常强大的范例

Answer 8

抱歉，我之前举的例子有误。 这不是正确的版本：

class Wheel
{
    public void RepairWhell() { }
}

class Chassis
{
    public void RepairChassis() { }
}

class Engine
{
    public void RepairEngine() { }
}

class CarWorkshop
{
    public string Repair(Wheel value)
    {
        value.RepairWhell();
        return "wheel repaired";
    }
    public string Repair(Chassis value)
    {
        value.RepairChassis();
        return "chassis repaired";
    }
    public string Repair(Engine value)
    {
        value.RepairEngine();
        return "engine repaired";
    }
}

class Program
{
    static void Main(string[] args)
    {
        var carWorkshop = new CarWorkshop();

        dynamic whell = new Wheel();
        dynamic chassis = new Chassis();
        dynamic engine = new Engine();

        Console.WriteLine(carWorkshop.Repair(whell));
        Console.WriteLine(carWorkshop.Repair(chassis));
        Console.WriteLine(carWorkshop.Repair(engine));
        Console.ReadLine();
    }
}

所以答案是肯定的。 C# 提供多调度。

Answer 9

您可以使用dynamic关键字在C#中实现多调度。

interface IA { }
interface IB { }
class CA1 : IA {}
class CA2 : IA {}
class CA11 : CA1 {}
class CB1 : IB {}
class CB2 : IB {}

class MD
{
    public enum X { X } ;
    public static void Foo(IA a, IB b, X dispatch = X.X) { Foo((dynamic)a, (dynamic)b); }
    static void Foo(IA a, IB b) { Console.WriteLine("IA IB"); }
    static void Foo(CA1 a, CB1 b) { Console.WriteLine("CA1 CB1"); }
    static void Foo(CA2 a, CB1 b) { Console.WriteLine("CA2 CB1"); }
    static void Foo(CA1 a, CB2 b) { Console.WriteLine("CA1 CB2"); }
    static void Foo(CA2 a, CB2 b) { Console.WriteLine("CA2 CB2"); }
    static void Foo(CA11 a, CB2 b) { Console.WriteLine("CA11 CB2"); }
}
class Program
{
    static void Main(string[] args)
    {
        var a1 = new CA1();
        var a11 = new CA11();
        var a2 = new CA2();
        var b1 = new CB1();
        var b2 = new CB2();
        MD.Foo(a1, b1);
        MD.Foo(a2, b1);
        MD.Foo(a1, b2);
        MD.Foo(a2, b2);
        MD.Foo(a11, b1);
        MD.Foo(a11, b2);
    }
}

Foo((dynamic)a,(dynamic)b)) 的解析是在运行时完成的，并根据 'a' 和 'b' 的具体类型选择重载的 Foo 方法之一。