获取通用服务类型的所有实现 - 包括开放泛型

Question

Background

I am writing some integration tests where I test implementations of a particular interface, IQueryMapping<TSource, TDest> . This interface exists to map from an IQueryable<TSource> to an IQueryable<TDest> . I want to make sure that they do not throw exceptions when compiling a query using Entity Framework.

The Task

I am lazy and I don't want to have to update my tests every time I create a new mapping! All I want to do is ensure that every mapping which is used by my application will pass the test. I can bootstrap my container and then find all implementations that are registered with it like so:

from r in Container.GetCurrentRegistrations()
let t = r.ServiceType
where t.IsGenericType && t.GetGenericTypeDefinition() == typeof (IQueryMapping<,>)
select r.GetInstance()

So far, so good!

The Problem

Alongside my concrete implementations, I have a default open generic mapper which performs basic automatic property mapping (remember, I am lazy and don't want to do this manually!)

container.RegisterOpenGeneric(typeof(IQueryMapping<,>), typeof(DefaultAutoMapping<,>));

Unfortunately, open generics don't seem to appear in Container.GetCurrentRegistrations() call. From the docs :

Returns an array with the current registrations. This list contains all explicitly registered types, and all implicitly registered instances. Implicit registrations are all concrete unregistered types that have been requested, all types that have been resolved using unregistered type resolution (using the ResolveUnregisteredType event), and requested unregistered collections. Note that the result of this method may change over time, because of these implicit registrations.

What I'd really like is for Simple Injector to tell me about every requested occurrence of IQueryMapping<,> in all registered components .

For example, if I have left IQueryMapping<Foo, Bar> as an open generic DefaultAutoMapping<,> and a registered component has the constructor signature

public MyComponent(IQueryMapping<Foo, Bar> mapping)
{
   ...
}

I would like the container to tell me about this specialised IQueryMapping<,> , so that I can request an instance of it and run it through my test.

Answer 1

A call to RegisterOpenGeneric will in the background hook a delegate onto the ResolveUnregisteredType event. This basically means that the container itself is completely unaware of the registration, and the registration will only get added when a closed-generic version of the registered abstraction is requested; either directly using a call to GetInstance() or indirectly because a type that depends on that abstraction is resolved.

The trick here is to call Verify() before calling GetCurrentRegistrations() . A call to Verify() will cause the container to build all expression trees, compile all delegates, and create all instances of all registrations that are known to the container. This will force the container to add the registrations of each found closed-generic version of that open-generic abstraction.

Long story short: call Verify() first.

Answer 2

As far as I am aware there is no built-in way to do this. However, while I was writing my question (as so often happens) I found a way to achieve what I want to do. It's probably far from ideal but...

From the Simple Injector Pipeline documentation it looks like this information isn't readily available in registration - it is only calculated at resolve time (at the point of 'Build ctor arguments').

Take 1

One thought that occurred to me is to iterate through every registered type and inspect its constructor for possible arguments:

from r in container.GetCurrentRegistrations()
from ctor in r.Registration.ImplementationType.GetConstructors()
from param in ctor.GetParameters()
let t = param.ParameterType
where t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IQueryMapping<,>)
select t;

However, this will only go down to the first level of registered types - in my project there are many open generic registrations.

Take 2

Fortunately, Simple Injector provides a way to retrieve an InstanceProducer based on a service type, which is all we need to create a recursive function:

public static class ContainerExtensions
{
    public static IEnumerable<InstanceProducer> GetInstanceProducers(this Container container)
    {
        return container.GetCurrentRegistrations()
            .SelectMany(x => GetInstanceProducers(container, x));
    }

    private static IEnumerable<InstanceProducer> GetInstanceProducers(Container container, InstanceProducer instanceProducer)
    {
        yield return instanceProducer;
        var producers = from ctor in instanceProducer.Registration
                            .ImplementationType.GetConstructors()
                        from param in ctor.GetParameters()
                        from producer in GetInstanceProducers(
                            container,
                            container.GetRegistration(param.ParameterType))
                        select producer;

        foreach (var producer in producers)
            yield return producer;
    }
}

This recurses through all registered types, looking through their constructors to find other types to search through. However, this still isn't perfect as we can't guarantee that a particular component should be resolved through its constructor (as opposed to, say, a factory method).

Take 3

One interesting method on InstanceProducer is BuildExpression() . This method creates an expression which, when executed will create the given instance. However, because it is an Expression it can also be traversed using an ExpressionVisitor. We can create an implementation of ExpressionVisitor that gathers up all of the types in the expression:

public static class ContainerExtensions
{
    public static IEnumerable<InstanceProducer> GetInstanceProducers(this Container container)
    {
        return container.GetCurrentRegistrations()
            .SelectMany(GetExpressionTypes)
            .Distinct()
            .Select(container.GetRegistration);
    }

    private static IEnumerable<Type> GetExpressionTypes(InstanceProducer instanceProducer)
    {
        var expression = instanceProducer.BuildExpression();
        var visitor = new TypeExpressionVisitor();
        visitor.Visit(expression);
        return visitor.Types;
    }

    private class TypeExpressionVisitor : ExpressionVisitor
    {
        private readonly List<Type> _types;

        public IEnumerable<Type> Types
        {
            get { return _types; }
        }

        public TypeExpressionVisitor()
        {
            _types = new List<Type>();
        }

        protected override Expression VisitNew(NewExpression node)
        {
            _types.Add(node.Type);
            return base.VisitNew(node);
        }

        protected override Expression VisitInvocation(InvocationExpression node)
        {
            _types.Add(node.Type);
            return base.VisitInvocation(node);
        }
    }
}

Finally! The types gathered by the ExpressionVisitor can be passed to container.GetRegistration(t) . The types will be concrete types, so we need to make a small change to the LINQ statement in Take 1, using a method to test if the service type is assignable to any generic version of IQueryMapping<,> :

public static IEnumerable<object[]> GetMappingObjects
{
    get
    {
        return
            from r in Container.GetInstanceProducers()
            where IsAssignableToGenericType(r.ServiceType, typeof(IQueryMapping<,>))
            select new[] {r.GetInstance()};
    }
}

public static bool IsAssignableToGenericType(Type givenType, Type genericType)
{
    while (true)
    {
        var interfaceTypes = givenType.GetInterfaces();

        if (givenType.IsGenericType && givenType.GetGenericTypeDefinition() == genericType)
            return true;

        if (interfaceTypes.Any(it => it.IsGenericType && it.GetGenericTypeDefinition() == genericType))
            return true;

        var baseType = givenType.BaseType;
        if (baseType == null)
            return false;

        givenType = baseType;
    }
}

I'd like to know if I'm doing this right or inadvertently digging myself into a hole, so please give me feedback if you are knowledgable in this area!