如何使用简单的注入器将其接口注册为单例类型？

Question

我有以下模型:

public interface IUserLookupService {
    Guid[] GetDirectChilds(Guid userId);
    Guid[] GetAllChilds(Guid userId);
    Guid GetDepartment(Guid userId);
}

public interface ICanRefreshCache{
    void Refresh();
}

public class XHandler : IEventHandler<UserNameChanged> { ... }
public class YHandler : IEventHandler<TeamCreated> { ... }

public class CachedUserLookupService
    : IUserLookupService,
    ICanRefreshCache,
    IEventHandler<UserNameChanged>
{
    private Func<ISession> _sessionFactory;
    private IDictionary<Guid, UserInfo> _users = new Dictionary<Guid, UserInfo>();

    public CachedUserLookupService(Func<ISession> sessionFactory) {
        _sessionFactory = sessionFactory;
    }

    public void Handle(UserNameChanged ev) {
        // change cache with new event parameters
    }

    public void Refresh() {
        var session = _sessionFactory();
        // get user from db then create userinfo...
    }

    public Guid[] GetDirectChilds(Guid userId) {
        // code
    }

    public Guid[] GetAllChilds(Guid userId) {
           // code
    }

    public Guid GetDepartment(Guid userId) {
        // code
    }

    public class UserInfo
    {
        public Guid Id { get; set; }
        public string FullName { get; set; }
        public Guid? ParentId {get;set;}
    }
}

public class CachedTeamService
    : ITeamService,
    ICanRefreshCache,
    IEventHandler<TeamCreated>{
    // similar with CachedUserLookupService
}

我的注册:

container.RegisterManyForOpenGeneric(typeof(IEventHandler<>),
    (closedServiceType, implementations) =>
    {
        container.RegisterAll(closedServiceType, implementations);
    },
    applicationAssembly, typeof(Constants).Assembly);

var serviceRegistrations = 
    from type in applicationAssembly.GetExportedTypes()
    where type.Name.EndsWith("Service")
    where !type.IsAbstract
    where !type.IsInterface
    select new
    {
        Services = type.GetInterfaces(),
        Implementation = type
    };

var lifeStyles = new Dictionary<Type, Lifestyle>()
{
    {typeof(CachedUserLookupService),Lifestyle.Singleton},
    {typeof(CachedTeamService),Lifestyle.Singleton}
};

List<Type> cacheableComponents = new List<Type>();
foreach (var reg in serviceRegistrations)
{
    foreach (var service in reg.Services)
    {
        Lifestyle lifeStyle;
        if (lifeStyles.TryGetValue(reg.Implementation, out lifeStyle) == false)
        {
            lifeStyle = Lifestyle.Singleton;
        }

        if (typeof(ICanRefreshCache) == service)
        {
            cacheableComponents.Add(reg.Implementation);
            continue;
        }

        container.Register(service, reg.Implementation, lifeStyle);
    }
}

container.RegisterAll(typeof(ICanRefreshCache), cacheableComponents);

我想在系统启动时使用ICanRefreshCache-> Refresh方法刷新所有缓存,所以我调用:

步骤1:

container.GetAllInstances<ICanRefreshCache>().Each(c=>c.Refresh());

第2步:

在我调用IEventHandler<UserNameChanged>或任何其他接口随时键入其属于CachedUserLookupService(或CachedTeamService)之后,返回实例与步骤1实例不同,因此此注册对我没有帮助.

我需要使用Simple Injector注册来提供以下呼叫.

// must return Singleton CachedUserLookupService + other 
// IEventHandler<UserNameChanged> implementations
container.GetAllInstances<IEventHandler<UserNameChanged>>(); 

// must return Singleton CachedTeamService + other 
// IEventHandler<TeamCreated> implementations
container.GetAllInstances<IEventHandler<TeamCreated>>();  

// must return Singleton CachedUserLookupService
container.GetInstance<IUserLookupService>();

// must return Singleton CachedTeamService
container.GetInstance<ITeamService>();

// must return Singleton CachedUserLookupService + Singleton CachedTeamService
container.GetAllInstances<ICanRefreshCache>(); 

Answer 1

注意:此答案中的信息已过时.Simple Injector v4的情况发生了很大变化.

如果我理解正确,您有一个实现多个接口的组件,并且您希望每个注册都映射到该组件的同一个实例.所以无论你是否解决了ITeamService,ICanRefreshCache或者IEventHandler<TeamCreated>,你想要获得相同的实例CachedTeamService.

在Simple Injector中执行此操作的一般方法是Registration手动创建实例并为每个接口注册它,如下所示:

var registration = 
    Lifestyle.Singleton.CreateRegistration<CachedTeamService>(container);

container.AddRegistration(typeof(ITeamService), registration);
container.AddRegistration(typeof(ICanRefreshCache), registration);
container.AddRegistration(typeof(IEventHandler<TeamCreated>), registration);

这在这里解释.

然而,您的情况稍微复杂一些,因为您使用RegisterManyForOpenGeneric正常注册混合批量注册.因此,您应该禁止批量注册所需的IEventHandler<TeamCreated>单例,或者您需要完全替换注册.

但是,在这种情况下无法替换注册,因为Simple Injector不允许您替换作为集合一部分的注册.所以我们可以按如下方式禁止该类型的注册:

Type[] typesToRegisterManually = new[]
{
    typeof(CachedTeamService)
};

container.RegisterManyForOpenGeneric(typeof(IEventHandler<>),
    (service, impls) =>
    {
        container.RegisterAll(service, impls.Except(typesToRegisterManually));
    },
    assemblies);

var registration = 
    Lifestyle.Singleton.CreateRegistration<CachedTeamService>(container);

container.AddRegistration(typeof(ITeamService), registration);
container.AddRegistration(typeof(ICanRefreshCache), registration);

// Using SimpleInjector.Advanced
container.AppendToCollection(typeof(IEventHandler<TeamCreated>), registration);

但我的经验是,复杂的注册通常表明代码中存在SOLID原则违规.很难对您的设计提供任何具体的反馈,但我发现具有这些多个接口的类很可能具有多个职责并且有多种原因需要更改(它们违反SRP),导致您在添加新功能时更改它们(这是OCP违规).

相反,我可以建议一些事情:

• 将泛型的逻辑移动IEventHandler<T>到自己的类中.事件处理程序显然是一个不同的责任,接口名称已经告诉你.然后,这个类可以依赖于从中提取逻辑的旧类,或者将事件处理程序所依赖的逻辑提取到它自己的类中,并让'old'类和事件处理程序都依赖于这个新的共享类.
• 在IUserLookupService自主安排似乎是一种变相的存储库,而这基本上接口意味着你违反了SRP,OCP和ISP(说明这篇文章).正如那篇文章所描述的那样,自定义查询值得拥有自己的抽象:IQueryHandler<TQuery, TResult>.这使得对它们应用横切关注点非常容易,使它们成为SOLID,并且使用它们进行注册非常简单container.RegisterManyForOpenGeneric.

这给你留下的是在大多数情况下只实现一个抽象的类,除了类实现的情况ICanRefreshCache.对于这种特殊情况,我建议制作一个允许在应用程序中触发所有内容的复合 ICanRefreshCache实现ICanRefreshCache.但是,不是将注入IEnumerable<ICanRefreshCache>复合到组合根中,而是让它依赖于容器.这允许您在运行时搜索完整配置以查找所有ICanRefreshCache实现.

这就是这样的复合材料看起来像:

public class CanRefreshCacheComposite : ICanRefreshCache
{
    private readonly Lazy<InstanceProducer[]> canRefreshProducers;

    public CanRefreshCacheComposite(Container container) {
        this.canRefreshProducers = 
            new Lazy<InstanceProducer[]>(() => GetProducers(container).ToArray());
    }

    public void Refresh() {
        foreach (var producer in this.canRefreshProducers.Value) {
            var refresher = (ICanRefreshCache)producer.GetInstance();
            refresher.Refresh();
        }
    }

    private IEnumerable<InstanceProducer> GetProducers(Container container) {
        return
            from producer in container.GetCurrentRegistrations()
            where typeof(ICanRefreshCache).IsAssignableFrom(
                producer.Registration.ImplementationType)
            select producer;
    }
}

您可以按如下方式注册:

container.RegisterSingle<ICanRefreshCache, CanRefreshCacheComposite>();

// To make sure all all ICanRefreshCache implementations that are part of
// a collection are known to the container, call Verify() when you're done
// registering.
container.Verify();

这样,您可以简单地依赖ICanRefreshCache于代码,Refresh在其上调用方法,复合将完成剩下的工作.