基于具体类型统一注册泛型

本文关键字：注册 泛型 于具体 类型 | 更新日期: 2023-09-27 18:09:51

我试图模仿我可以在Ninject中配置的行为，只使用Unity代替。

我正在尝试使用缓存存储库模式，给出以下类和接口:

public interface IRepository<T>
{
    T Get();
}
public class SqlRepository<T> : IRepository<T>
    where T : new()
{
    public T Get()
    {
        Console.WriteLine("Getting object of type '{0}'!", typeof(T).Name);
        return new T();
    }
}
public class CachedRepository<T> : IRepository<T>
    where T : class
{
    private readonly IRepository<T> repository;
    public CachedRepository(IRepository<T> repository)
    {
        this.repository = repository;
    }
    private T cachedObject;
    public T Get()
    {
        if (cachedObject == null)
        {
            cachedObject = repository.Get();
        }
        else
        {
            Console.WriteLine("Using cached repository to fetch '{0}'!", typeof(T).Name);
        }
        return cachedObject;
    }
}

基本上，任何时候我的应用程序使用IRepository<T>，它应该得到CachedRepository<T>的一个实例。但是在CachedRepository<T>内部，它应该获取SqlRepository<T>的实际SQL存储库。在Ninject中，我使用以下命令完成了此操作:

ninjectModule.Bind(typeof(IRepository<>)).To(tyepof(SqlRepository<>)).WhenInjectedExactlyInto(tyepof(CachedRepository<>));
ninjectModule.Bind(typeof(IRepository<>)).To(tyepof(CachedRepository<>));

在Unity中，我该如何完成同样的事情?我有一个用于非通用存储库的版本:

UnityContainer container = new UnityContainer();
container.RegisterType<IWidgetRepository, CachedWidgetRepository>(new InjectionMember[] { new InjectionConstructor(new SqlWidgetRepository()) });

但是这种语法在通用存储库中根本不起作用，因为你不能在没有语法错误的情况下说new SqlRepository<>。什么好主意吗?

基于具体类型统一注册泛型

假设您不想注册每个可能的通用名，如下所示:

container.RegisterType<IRepository<Things>, CachedRepository<Things>>(new InjectionMember[] {new InjectionConstructor(new SqlRepository<Things>())});
container.RegisterType<IRepository<OtherThings>, CachedRepository<OtherThings>>(new InjectionMember[] {new InjectionConstructor(new SqlRepository<OtherThings>())});

您可以使用自定义注入工厂，这只是"编写您自己的工厂函数"的一种奇特方式。

// We will ask Unity to make one of these, so it has to resolve IRepository<Things>
public class UsesThings
{
    public readonly IRepository<Things> ThingsRepo;
    public UsesThings(IRepository<Things> thingsRepo)
    {
        this.ThingsRepo = thingsRepo;
    }
}

class Program
{
    static void Main(string[] args)
    {
        var container = new UnityContainer();
        // Define a custom injection factory.
        // It uses reflection to create an object based on the requested generic type.
        var cachedRepositoryFactory = new InjectionFactory((ctr, type, str) =>
            {
                var genericType = type.GenericTypeArguments[0];
                var sqlRepoType = typeof (SqlRepository<>).MakeGenericType(genericType);
                var sqlRepoInstance = Activator.CreateInstance(sqlRepoType);
                var cachedRepoType = Activator.CreateInstance(type, sqlRepoInstance);
                return cachedRepoType;
            });
        // Register our fancy reflection-loving function for IRepository<>
        container.RegisterType(typeof(IRepository<>), typeof(CachedRepository<>), new InjectionMember[] { cachedRepositoryFactory });
        // Now use Unity to resolve something
        var usesThings = container.Resolve<UsesThings>();
        usesThings.ThingsRepo.Get(); // "Getting object of type 'Things'!"
        usesThings.ThingsRepo.Get(); // "Using cached repository to fetch 'Things'!"
    }
}
相关文章：