Question

…or are they the same thing? I notice that each has its own Wikipedia entry: Polymorphism, Multiple Dispatch, but I’m having trouble seeing how the concepts differ.

Edit: And how does Overloading fit into all this?

Answer 1

Polymorphism is the facility that allows a language/program to make decisions during runtime on which method to invoke based on the types of the parameters sent to that method.

The number of parameters used by the language/runtime determines the ‘type’ of polymorphism supported by a language.

Single dispatch is a type of polymorphism where only one parameter is used (the receiver of the message – this, or self) to determine the call.

Multiple dispatch is a type of polymorphism where in multiple parameters are used in determining which method to call. In this case, the reciever as well as the types of the method parameters are used to tell which method to invoke.

So you can say that polymorphism is the general term and multiple and single dispatch are specific types of polymorphism.

Addendum: Overloading happens during compile time. It uses the type information available during compilation to determine which type of method to call. Single/multiple dispatch happens during runtime.

Sample code:

using NUnit.Framework;  namespace SanityCheck.UnitTests.StackOverflow {     [TestFixture]     public class DispatchTypes     {         [Test]         public void Polymorphism()         {             Baz baz = new Baz();             Foo foo = new Foo();              // overloading - parameter type is known during compile time             Assert.AreEqual('zap object', baz.Zap('hello'));             Assert.AreEqual('zap foo', baz.Zap(foo));               // virtual call - single dispatch. Baz is used.             Zapper zapper = baz;             Assert.AreEqual('zap object', zapper.Zap('hello'));             Assert.AreEqual('zap foo', zapper.Zap(foo));               // C# has doesn't support multiple dispatch so it doesn't             // know that oFoo is actually of type Foo.             //             // In languages with multiple dispatch, the type of oFoo will              // also be used in runtime so Baz.Zap(Foo) will be called             // instead of Baz.Zap(object)             object oFoo = foo;             Assert.AreEqual('zap object', zapper.Zap(oFoo));         }          public class Zapper         {             public virtual string Zap(object o) { return 'generic zapper' ; }             public virtual string Zap(Foo f) { return 'generic zapper'; }         }          public class Baz : Zapper         {             public override string Zap(object o) { return 'zap object'; }             public override string Zap(Foo f) { return 'zap foo'; }         }          public class Foo { }     } }