Ninject：如何将泛型类型动态注入绑定的模板对象

Question

I have a generic template class that I have configured in my Ninject configuration.

Template Class:

public Repository<T> : IRepository<T>
{
    //...
}

Ninject Configuration:

container.Bind(typeof(IRepository<>)).To(typeof(Repository<>));

Also, I have a class that needs to dynamically create multiple instances of IRepository<T> , in which T is dynamic for each instance.

Is there a way to do this with Ninject? The pseudo-code would be something as follows:

foreach(Type genericType in repositoryTypes)
{
    var tempRepository = WebManager.Get(IRepository<genericType>); //how should this actually be?

    //do stuff with tempRepository
}

The WebManager would have something like below:

public static class WebManager 
{
    public static object Get(Type t)
    {
        object service = GlobalConfiguration.Configuration.DependencyResolver.GetService(t);
        return service;
    }
}

Answer 1

Of course this works, it's very simple:

foreach(Type genericType in repositoryTypes)
{
    object tempRepository = WebManager.Get(typeof(IRepository).MakeGenericType(genericType));
    //do stuff with tempRepository
}

But then it get's trickier. How will you use this object ? You'll need to use reflection. It's simpler to use it once than for every call. So we can adjust/write the code as follows:

internal class Foo
{
    private static readonly MethodInfo DoStuffToRepositoryForMethod =
        typeof(Foo).GetMethod(
            "DoStuffToRepositoryFor",
            BindingFlags.Instance | BindingFlags.NonPublic);

    private readonly IResolutionRoot resolutionRoot;

    public Foo(IResolutionRoot resolutionRoot)
    {
        this.resolutionRoot = resolutionRoot;
    }

    public void DoStuffToRepositories(params Type[] entityTypes)
    {
        foreach (Type entityType in entityTypes)
        {
            MethodInfo doStuffMethod = DoStuffToRepositoryForMethod
                .MakeGenericMethod(entityType);
            doStuffMethod.Invoke(this, new object[0]);
        }
    }

    private void DoStuffToRepositoryFor<T>()
    {
        var repository = this.resolutionRoot.Get<IRepository<T>>();
        repository.DoSomething();
    }
}

and just for reference, this is a test showing that it works:

public class Test
{
    [Fact]
    public void TestIt()
    {
        var kernel = new StandardKernel();
        kernel.Bind(typeof(IRepository<>)).To(typeof(Repository<>));

        var foo = kernel.Get<Foo>();

        foo.DoStuffToRepositories(typeof(string), typeof(int));
    }
}

Don't employ magic if you don't have to

But i think the more important question is: why do you want to do this? How do you know the list of entity types and entities to do something for? In most cases there's an alternative way which doesn't involve that much "magic".