Mystery with dynamic type & double dispatch

Question

Recently I came across an interesting problem trying to implement double dispatch via dynamic type.

A little background: in one of my projects I use StructureMap container and dynamic type as a clean way to dispatch method calls at runtime. After updating StructureMap container to the newer version(3), some of my unit-tests started to hang eternally.

To reproduce the problem I created 2 maximally simplified unit-tests: The first test hangs forever on the line marked with (*), the second test passes as expected. The only difference between them is that method of the first one returns StructureMap's object of type LambdaInstance.

The hanging test:

    [TestFixture]
    [Category("Unit")]
    public class when_trying_to_call_method_with_dynamic_argument1
    {            
        private class A {}

        private static LambdaInstance<object> Method(A obj)
        {
            throw new NotImplementedException();
        }

        [Test]
        [ExpectedException(typeof(NotImplementedException))]
        public void should_succeed()
        {
            var instance = (dynamic)new A();
            Method(instance); //(*)hangs forever on this line              
        }
    }

The passing test:

    [TestFixture]
    [Category("Unit")]
    public class when_trying_to_call_method_with_dynamic_argument2
    {            
        private class A {}

        private static object Method(A obj)
        {
            throw new NotImplementedException();
        }

        [Test]
        [ExpectedException(typeof(NotImplementedException))]
        public void should_succeed()
        {
            var instance = (dynamic)new A();
            Method(instance);
        }
    }

How it could be possible? Or I am just tired and need to go sleep?

Anyway, it's conceptual and educational question, rather than willing to find fix for the particular problem in the particular library.

UPDATE1: Verified that problem exists for 4.0 & 4.5 target Frameworks, verified in VS2010(SP1), VS2013.

UPDATE2: Simple console application is hanging on the same line as well(so, it's not the problem with test-runner):

class Program
{
    private class A { }

    private static LambdaInstance<object> Method(A obj)
    {
        throw new NotImplementedException();
    }

    static void Main(string[] args)
    {
        var instance = (dynamic)new A();
        Method(instance); //(*)hangs forever on this line            
    }
}

Also I created standalone example on GitHub.

Answer 1

The issue is located at StructureMap's LambdaInstance<T> class inheritance. Usage of C# dynamic involves creation of polymorphic callsites, which ones does use runtime binders.

Consider simplified inheritance tree for LambdaInstance class:

class Program
{
    private static LambdaInstance<object> Method(object obj)
    {
        throw new NotImplementedException();
    }

    static void Main(string[] args)
    {
        var instance = (dynamic)new object();
        Method(instance);
    }
}

public class LambdaInstance<T> : LambdaInstance<T, T>
{

}

public class LambdaInstance<T, TPluginType> : ExpressedInstance<LambdaInstance<T, TPluginType>, T, TPluginType>
{

}

public abstract class ExpressedInstance<T>
{

}

public abstract class ExpressedInstance<T, TReturned, TPluginType> : ExpressedInstance<T>
{

}

As shown above LambdaInstance<T, TPluginType> inherites ExpressedInstance<T, TReturned, TPluginType>, but with specialization of T:LambdaInstance<T, TPluginType>. So specialization of generic parameter T is child type definition - LambdaInstance<T, TPluginType>. This creates circular reference in a case of getting constructed type at runtime as required by runtime binders for invariant polymorphic behaviour.

If you need the source of issue take a look at private methods LoadSymbolsFromType(Type originalType) and GetConstructedType(Type type, AggregateSymbol agg) of Microsoft.CSharp.RuntimeBinder.SymbolTable class (Microsoft.CSharp.dll assembly). The methods LoadSymbolsFromType and GetConstructedType recusively calls each other, while instantiating new types.

To check this without even having framework sources, try to dissect generics specialization by providing predefined type, i.e. System.Int32 for example.

class Program
{
    private static LambdaInstance<object> Method(object obj)
    {
        throw new NotImplementedException();
    }

    static void Main(string[] args)
    {
        var instance = (dynamic)new object();
        Method(instance);
    }
}

public class LambdaInstance<T> : LambdaInstance<T, int>
{

}

public class LambdaInstance<T, TPluginType> : ExpressedInstance<LambdaInstance<T, TPluginType>, int, TPluginType>
{

}

public abstract class ExpressedInstance<T>
{

}

public abstract class ExpressedInstance<T, TReturned, TPluginType> : ExpressedInstance<T>
{

}

Run application. The System.StackOverflowException will be thrown. Using debugger and disassembly mode - the issue source would be System.RuntimeTypeHandle.Instantiate(System.Type[]).