Что - Единственное и Несколько Отправка (относительно.NET)?

Несколько диспетчеризируют, "форма" перегрузки...

Например, C# является единственной отправкой потому что, если удается что метод звонить на основе только одного аргумента, "этого" указателя. Когда у Вас есть что-то вроде этого:

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

Полученный метод. 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 поскольку C# делает единственную отправку на объектном указателе (b) и затем использует информацию о времени компиляции для решения который метод звонить. Даже при том, что потоком является MemoryStream, единственная система отправки проигнорирует это.

В системе мультиотправки объектный указатель посмотрят на (как в C#), И типы выполнения аргументов будут исследованы. В вышеупомянутом примере, потому что потоком является на самом деле MemoryStream, который система назвала бы Процессом (MemoryStream) метод.

Мультиотправка связана с перегрузкой метода, но не тем же. Первый - динамическое решение во время выполнения, последний является статическим решением времени компиляции. Существует неявно преимущество гибкости, но стоимость производительности для мультидиспетчеризирования поэтому.

AFAIK, который язык может поддерживать также, но не оба, хотя оба могут быть моделированы (мультиотправка может быть моделирована с посетителями). C# определяет типы данных во время компиляции и поэтому не является языком мультиотправки, таким образом, никакие примеры не возможны.

(протест: я не 100% на этом),

приложение: на самом деле Википедия имеет статью об этом, которое кажется довольно полным, ох и полезный пример LISP

В OO languaes текст:

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

Средства, что объект b передается сообщение Foo с параметрами c и d. Единственная отправка означает, что ТОЛЬКО ОДИН аспект этой системы ответственен за определение во времени выполнения, которым (возможно многих) методы на самом деле позвонят Foo.

Образцовый Java, c# и большая часть другого использования языков OO - то, что только тип выполнения 'b' добирается для 'решения', каков фактический вызов метода. Таким образом, если у Вас есть два реализации SomeType, оба из которых обеспечивают другую реализацию Foo затем решение, относительно которого можно использовать, базируется только, на котором тип b, оказывается, в той точке. ЕСЛИ существует несколько перегрузок Foo затем решение, относительно которого перегрузка использовать является решением времени компиляции, базирующимся только на времени компиляции, знают типы b, c и d.

Это затем - единственная отправка, единственная предпочтительная точка является системой типов, связанной с b.

Несколько, которые Отправка, во времени выполнения, позволила бы типам выполнения b, c и d решать, какой метод назвать (такое решение неизбежно более сложно).

В более динамической системе, где понятие четко определенных типов является большим количеством жидкости (говорят, что система на основе прототипов, а не модели наследования Вы знаете от c ++/java/C#) затем решение, относительно какой метод вызвать вместо этого был бы полностью до фактических экземпляров b, c и d.

#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++ не может выяснить во времени выполнения ли a Pet на самом деле a Cat или a Dog.

Если бы был некоторый способ сделать это во времени выполнения (так, чтобы код выше скомпилировал бы с прокомментированной непрокомментированной строкой), C++, как говорили бы, поддерживал бы, несколько диспетчеризируют, или мультиметоды.

Единственный / несколько диспетчеризируют, своего рода перегрузка во время выполнения. Единственная отправка чаще всего известна как виртуальные функции. Точная функция, вызванная, когда Вы вызываете виртуальную функцию, решена на основе типа выполнения объекта. Двойная отправка является тем же самым, расширенным на работу с двумя объектами - обычно this параметр и второй параметр. Можно реализовать это без слишком большой трудности с помощью Шаблона Vistor. Несколько диспетчеризируют, далее расширяет это понятие до большего количества параметров, но значительно более тверд реализовать на языках как 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)

В C # 4.0 мультиметоды включаются с помощью нового ключевого слова dynamic:

using System; пример пространства имен { класс 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)
    {
        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 #.

Извините, я приведу пример, прежде чем он ошибочен. Это неправильная версия:

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 # поддерживает множественную отправку.