So in an earlier blog post I showed dynamic dispatching using the dynamic runtime in .NET4, in the example the stream gets passed to the correct ReadStream method depending on it’s runtime type.

class Reader
{
    public void Read(Stream stream)
    {
        dynamic s = stream;
        ReadStream(s);
    }

    private void ReadStream(FileStream stream)
    {
        // ...
    }

    private void ReadStream(MemoryStream stream)
    {
        // ...
    }
}

Lets dig a little deeper and look at what the C# compiler outputs, and get a feel for what the cost of using dynamic dispatching is.

[CompilerGenerated]
private static class SiteContainer
{
    public static CallSite<Action<CallSite, Reader, object>> Site;
}

public void Read(Stream stream)
{
    if (SiteContainer.Site == null)
    {
        var argumentInfos = new[]
        {
            CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null),
            CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)
        };
        var binder = Binder.InvokeMember(
            CSharpBinderFlags.InvokeSimpleName
            | CSharpBinderFlags.ResultDiscarded,
            "ReadStream", null, typeof (Reader),
            argumentInfos);
        SiteContainer.Site = CallSite<Action<CallSite, Reader, object>>.Create(binder);
    }
    SiteContainer.Site.Target(SiteContainer.Site, this, stream);
}

The above code is what the compiler replaces the Read method with.

The first time Read is called a dynamic call site binder to our ReadStream methods is created, this call site is then cached in the static SiteContainer so the hit of the call site create is only taken once. Target delegate is then invoked which dispatches the call to the correct ReadStream method.

The Target delegate is probably generated with a expression tree (probably why System.Runtime.CompilerServices.CallSiteOps exists to give access to internal CallSite<> members and why the call site is a parameter to the delegate) which would mean that the Target delegate is compiled once.

I highlighted all parts in the Read method that have something to do with the stream parameter in yellow.

To be able to do the dynamic dispatching the CSharpArgumentInfo for stream is flagged with CSharpArgumentInfoFlags.None resulting in that the type information will be looked up at runtime. This in contrast to the Reader class instance (highlighted in green) that is flagged as UseCompileTimeType that is always known at compile time.

As you probably concluded there is a fairly high initial cost of setting up a call site and generating delegates, this is on the other hand only done once and then cached.

In the example bellow we want the correct ReadStream method to be called when we pass it a stream. This example does not compile because the compiler doesn’t have enough type information at compile time to decide what method to run.

class Reader
{
    public void Read(Stream stream)
    {
        ReadStream(stream);
    }

    private void ReadStream(MemoryStream stream)
    {
        // ...
    }

    private void ReadStream(FileStream stream)
    {
        // ...
    }
}

To resolve the lookup error we have to manually add the runtime type checks, and a appropriate cast
to the correct type.

public void Read(Stream stream)
{
    if (stream is MemoryStream)
    {
        ReadStream((MemoryStream)stream);
    }
    else if (stream is FileStream)
    {
        ReadStream((FileStream)stream);
    }
}

In .NET4 the dynamic runtime was introduces and with it some nifty runtime features. One of these features
is dynamic dispatching that tells the compiler don’t worry about the type the dynamic runtime will invoke the correct method at runtime. For our example the code would look like this:

public void Read(Stream stream)
{
    dynamic s = stream;
    ReadStream(s);
}

So what will happen when we pass e.g. a BufferedStream to our method? You will get a
RuntimeBindingException from the dynamic runtime telling you the best overloaded method had some invalid argument. This best match error is a bit misleading because when no match is found it will take the first method in the list of declared method and return that as the best match, so it doesn’t have any significance.

A place where I found the best use for dynamic dispatching is when matching AST (Abstract Syntax Tree) nodes in a visitor. Instead of having a switch statement containing up to a 100 or more cases that also needs to be kept in sync with the rest of the implementation I have two lines of code.