public static IIocBuilder UseStoveRabbitMQ(
[NotNull] this IIocBuilder builder,
[NotNull] Func <IStoveRabbitMQConfiguration, IStoveRabbitMQConfiguration> rabbitMQConfigurer)
{
Check.NotNull(rabbitMQConfigurer, nameof(rabbitMQConfigurer));
builder
.RegisterServices(r =>
{
r.RegisterAssemblyByConvention(typeof(StoveRabbitMQRegistrationExtensions).GetAssembly());
r.Register <IStoveRabbitMQConfiguration, StoveRabbitMQConfiguration>(Lifetime.Singleton);
r.Register <IMessageBus, StoveRabbitMQMessageBus>();
r.Register(ctx => rabbitMQConfigurer);
});
builder.RegisterServices(r => r.UseBuilder(cb =>
{
cb.Register(ctx =>
{
var configuration = ctx.Resolve <IStoveRabbitMQConfiguration>();
IBusControl busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
EnsureStoveDefaults(cfg, configuration);
});
return(busControl);
}).SingleInstance()
.As <IBusControl>()
.As <IBus>();
}));
return(builder);
}
public void RegisterRepositories(AutoRepositoryTypesAttribute defaultRepositoryTypes)
{
AutoRepositoryTypesAttribute autoRepositoryAttr = defaultRepositoryTypes;
foreach (EntityTypeInfo entityTypeInfo in _entityTypeInfoFinder(_dbContextType))
{
Type implType;
Type primaryKeyType = _primaryKeyTypeFinder(entityTypeInfo.EntityType);
if (primaryKeyType == typeof(int))
{
Type genericRepositoryType = autoRepositoryAttr.RepositoryInterface.MakeGenericType(entityTypeInfo.EntityType);
implType = autoRepositoryAttr.RepositoryImplementation.GetGenericArguments().Length == 1
? autoRepositoryAttr.RepositoryImplementation.MakeGenericType(entityTypeInfo.EntityType)
: autoRepositoryAttr.RepositoryImplementation.MakeGenericType(entityTypeInfo.DeclaringType, entityTypeInfo.EntityType);
_iocBuilder.RegisterServices(r => r.UseBuilder(cb => cb.RegisterType(implType).As(genericRepositoryType).AsSelf().AsImplementedInterfaces().WithPropertyInjection()));
}
else
{
Type genericRepositoryTypeWithPrimaryKey = autoRepositoryAttr.RepositoryInterfaceWithPrimaryKey.MakeGenericType(entityTypeInfo.EntityType, primaryKeyType);
implType = autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.GetGenericArguments().Length == 2
? autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(entityTypeInfo.EntityType, primaryKeyType)
: autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(entityTypeInfo.DeclaringType, entityTypeInfo.EntityType, primaryKeyType);
_iocBuilder.RegisterServices(r => r.UseBuilder(cb => cb.RegisterType(implType).As(genericRepositoryTypeWithPrimaryKey).AsSelf().AsImplementedInterfaces().WithPropertyInjection()));
}
}
}
public static void RegisterRepositories(Type dbContextType, IIocBuilder builder)
{
AutoRepositoryTypesAttribute autoRepositoryAttr = dbContextType.GetSingleAttributeOrNull <AutoRepositoryTypesAttribute>() ??
EfAutoRepositoryTypes.Default;
foreach (EntityTypeInfo entityTypeInfo in DbContextHelper.GetEntityTypeInfos(dbContextType))
{
Type implType;
Type primaryKeyType = EntityHelper.GetPrimaryKeyType(entityTypeInfo.EntityType);
if (primaryKeyType == typeof(int))
{
Type genericRepositoryType = autoRepositoryAttr.RepositoryInterface.MakeGenericType(entityTypeInfo.EntityType);
implType = autoRepositoryAttr.RepositoryImplementation.GetGenericArguments().Length == 1
? autoRepositoryAttr.RepositoryImplementation.MakeGenericType(entityTypeInfo.EntityType)
: autoRepositoryAttr.RepositoryImplementation.MakeGenericType(entityTypeInfo.DeclaringType, entityTypeInfo.EntityType);
builder.RegisterServices(r => r.UseBuilder(cb => cb.RegisterType(implType).As(genericRepositoryType).AsImplementedInterfaces().InjectPropertiesAsAutowired()));
}
else
{
Type genericRepositoryTypeWithPrimaryKey = autoRepositoryAttr.RepositoryInterfaceWithPrimaryKey.MakeGenericType(entityTypeInfo.EntityType, primaryKeyType);
implType = autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.GetGenericArguments().Length == 2
? autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(entityTypeInfo.EntityType, primaryKeyType)
: autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(entityTypeInfo.DeclaringType, entityTypeInfo.EntityType, primaryKeyType);
builder.RegisterServices(r => r.UseBuilder(cb => cb.RegisterType(implType).As(genericRepositoryTypeWithPrimaryKey).AsImplementedInterfaces().InjectPropertiesAsAutowired()));
}
}
}
public static IIocBuilder UseStoveNLog(this IIocBuilder builder)
{
builder.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()));
builder.RegisterServices(r => r.Register <ILogger>(context => new LoggerAdapter(LogManager.GetCurrentClassLogger()), Lifetime.Singleton));
builder.RegisterServices(r => r.UseBuilder(containerBuilder => containerBuilder.RegisterModule <NLogRegistrarModule>()));
return(builder);
}
public static IIocBuilder UseStoveRabbitMQ(
[NotNull] this IIocBuilder builder,
[NotNull] Func <IStoveRabbitMQConfiguration, IStoveRabbitMQConfiguration> rabbitMQConfigurer,
Action <IRabbitMqHost, IRabbitMqBusFactoryConfigurator, IComponentContext> consumerConfigurer
)
{
Check.NotNull(rabbitMQConfigurer, nameof(rabbitMQConfigurer));
Check.NotNull(consumerConfigurer, nameof(consumerConfigurer));
builder
.RegisterServices(r =>
{
r.RegisterAssemblyByConvention(typeof(StoveRabbitMQRegistrationExtensions).GetAssembly());
r.Register <IStoveRabbitMQConfiguration, StoveRabbitMQConfiguration>(Lifetime.Singleton);
r.Register <IMessageBus, StoveRabbitMQMessageBus>();
r.Register(ctx => rabbitMQConfigurer);
});
builder.RegisterServices(r => r.UseBuilder(cb =>
{
cb.Register(ctx =>
{
var configuration = ctx.Resolve <IStoveRabbitMQConfiguration>();
IBusControl busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
IRabbitMqHost host = cfg.Host(new Uri(configuration.HostAddress), h =>
{
h.Username(configuration.Username);
h.Password(configuration.Password);
});
if (configuration.UseRetryMechanism)
{
cfg.UseRetry(rtryConf => { rtryConf.Immediate(configuration.MaxRetryCount); });
}
if (configuration.PrefetchCount.HasValue)
{
cfg.PrefetchCount = (ushort)configuration.PrefetchCount;
}
if (configuration.ConcurrencyLimit.HasValue)
{
cfg.UseConcurrencyLimit(configuration.ConcurrencyLimit.Value);
}
consumerConfigurer(host, cfg, ctx);
});
return(busControl);
}).SingleInstance()
.As <IBusControl>()
.As <IBus>();
}));
return(builder);
}
public static IIocBuilder UseStoveEntityFramework(this IIocBuilder builder)
{
builder.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()));
builder.RegisterServices(r => r.Register <IEfUnitOfWorkFilterExecuter, IEfUnitOfWorkFilterExecuter, EfDynamicFiltersUnitOfWorkFilterExecuter>());
builder.RegisterServices(r => r.RegisterGeneric(typeof(IDbContextProvider <>), typeof(UnitOfWorkDbContextProvider <>)));
builder.RegisterServices(r => r.Register <IUnitOfWorkDefaultOptions, UnitOfWorkDefaultOptions>(Lifetime.Singleton));
List <Type> dbContextTypes = typeof(StoveDbContext).AssignedTypes().ToList();
dbContextTypes.ForEach(type => EfRepositoryRegistrar.RegisterRepositories(type, builder));
return(builder);
}
public static IIocBuilder UseStoveRedisCaching(this IIocBuilder builder, Func <IStoveRedisCacheConfiguration, IStoveRedisCacheConfiguration> redisCacheConfigurer = null)
{
builder.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()));
builder.RegisterServices(r => r.Register <IStoveRedisCacheConfiguration, StoveRedisCacheConfiguration>(Lifetime.Singleton));
builder.RegisterServices(r => r.RegisterType <StoveRedisCache>());
builder.RegisterServices(r => r.Register <ICacheManager, StoveRedisCacheManager>());
if (redisCacheConfigurer != null)
{
builder.RegisterServices(r => r.Register(ctx => redisCacheConfigurer));
}
return(builder);
}
public static IIocBuilder UseStoveRabbitMQ(this IIocBuilder builder, Func <IStoveRabbitMQConfiguration, IStoveRabbitMQConfiguration> rabbitMQConfigurer = null)
{
builder
.RegisterServices(r =>
{
r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());
r.Register <IStoveRabbitMQConfiguration, StoveRabbitMQConfiguration>(Lifetime.Singleton);
r.Register <IMessageBus, RabbitMQMessageBus>();
if (rabbitMQConfigurer != null)
{
r.Register(ctx => rabbitMQConfigurer);
}
});
builder.RegisterServices(r => r.UseBuilder(cb =>
{
cb.Register(ctx =>
{
var configuration = ctx.Resolve <IStoveRabbitMQConfiguration>();
IBusControl busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
IRabbitMqHost host = cfg.Host(new Uri(configuration.HostAddress), h =>
{
h.Username(configuration.Username);
h.Password(configuration.Password);
});
if (configuration.UseRetryMechanism)
{
cfg.UseRetry(rtryConf =>
{
rtryConf.Immediate(configuration.MaxRetryCount);
});
}
cfg.ReceiveEndpoint(host, configuration.QueueName, ec => { ec.LoadFrom(ctx); });
});
return(busControl);
}).SingleInstance()
.As <IBusControl>()
.As <IBus>();
}));
return(builder);
}
public static IIocBuilder UseVirgo(this IIocBuilder builder)
{
var assembly = typeof(VirgoExtensions).Assembly;
builder.RegisterServices(r => r.RegisterAssemblyByConvention(assembly));
return(builder);
}
private static void AutoRegisterRepositories(IIocBuilder builder)
{
builder.RegisterServices(r => r.UseBuilder(cb =>
{
if (!cb.Properties.ContainsKey(StoveConsts.OrmRegistrarContextKey))
{
throw new StoveInitializationException("Dapper registration should be after EntityFramework or NHibernate registration" +
" use StoveEntityFramework() or StoveNHibernate() registration methods before use StoveDapper().");
}
var ormRegistrars = cb.Properties[StoveConsts.OrmRegistrarContextKey].As <IList <ISecondaryOrmRegistrar> >();
ormRegistrars.ForEach(registrar =>
{
switch (registrar.OrmContextKey)
{
case StoveConsts.Orms.EntityFramework:
registrar.RegisterRepositories(EfBasedDapperAutoRepositoryTypes.Default);
break;
case StoveConsts.Orms.NHibernate:
registrar.RegisterRepositories(NhBasedDapperAutoRepositoryTypes.Default);
break;
}
});
}));
}
private static void RegisterStoveDefaults([NotNull] this IIocBuilder builder)
{
builder.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()))
.RegisterServices(r => r.Register <IGuidGenerator>(context => SequentialGuidGenerator.Instance, Lifetime.Singleton))
.RegisterServices(r => r.Register <IStoveStartupConfiguration, StoveStartupConfiguration>(Lifetime.Singleton))
.RegisterServices(r => r.Register <IBackgroundJobConfiguration, BackgroundJobConfiguration>(Lifetime.Singleton))
.RegisterServices(r => r.Register <IModuleConfigurations, ModuleConfigurations>(Lifetime.Singleton))
.RegisterServices(r => r.Register <IStoveBootstrapperManager, StoveBootstrapperManager>(Lifetime.Singleton))
.RegisterServices(r => r.Register <IUnitOfWorkDefaultOptions, UnitOfWorkDefaultOptions>(Lifetime.Singleton))
.RegisterServices(r => r.Register <IStoveAssemblyFinder, StoveAssemblyFinder>(Lifetime.Singleton))
.RegisterServices(r => r.Register <ICachingConfiguration, CachingConfiguration>(Lifetime.Singleton))
.RegisterServices(r => r.Register <ITypeFinder, TypeFinder>(Lifetime.Singleton))
.RegisterServices(r => r.RegisterGeneric(typeof(IAmbientScopeProvider <>), typeof(DataContextAmbientScopeProvider <>)));
builder.RegisterServices(r => r.OnDisposing += (sender, args) => { args.Context.Resolver.Resolve <IStoveBootstrapperManager>().ShutdownBootstrappers(); });
}
public static IIocBuilder UseInfrastructure(this IIocBuilder builder)
{
var assembly = typeof(InfrastruxtureExtensions).Assembly;
builder.RegisterServices(r => r.RegisterAssemblyByConvention(assembly));
return(builder);
}
public static IIocBuilder UseStoveMapster([NotNull] this IIocBuilder builder)
{
return(builder
.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()))
.RegisterServices(r => r.Register <IStoveMapsterConfiguration, StoveMapsterConfiguration>(Lifetime.Singleton))
.RegisterServices(r => r.Register <IObjectMapper, MapsterObjectMapper>(Lifetime.Singleton)));
}
public static IIocBuilder UseStoveNHibernate(this IIocBuilder builder, Func <IStoveNHibernateConfiguration, IStoveNHibernateConfiguration> stoveNhConfigurer)
{
return(builder.RegisterServices(r =>
{
r.Register(ctx => stoveNhConfigurer);
r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());
r.RegisterGeneric(typeof(IRepository <>), typeof(NhRepositoryBase <>));
r.RegisterGeneric(typeof(IRepository <,>), typeof(NhRepositoryBase <,>));
r.Register(ctx =>
{
var configuration = ctx.Resolver.Resolve <IStoveNHibernateConfiguration>();
Func <IStoveNHibernateConfiguration, IStoveNHibernateConfiguration> configurer = ctx.Resolver.Resolve <IStoveStartupConfiguration>().GetConfigurerIfExists <IStoveNHibernateConfiguration>();
configuration = configurer(configuration);
return configuration
.FluentConfiguration
.ExposeConfiguration(cfg => cfg.SetInterceptor(ctx.Resolver.Resolve <StoveNHibernateInterceptor>()))
.BuildSessionFactory();
}, Lifetime.Singleton);
var ormRegistrars = new List <ISecondaryOrmRegistrar>();
ormRegistrars.Add(new NhBasedSecondaryOrmRegistrar(builder));
r.UseBuilder(cb => { cb.Properties[StoveConsts.OrmRegistrarContextKey] = ormRegistrars; });
}));
}
/// <summary>
/// Uses the stove migrator.
/// </summary>
/// <param name="builder">The builder.</param>
/// <returns></returns>
public static IIocBuilder UseStoveMigrator(this IIocBuilder builder)
{
return(builder.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()))
.UseStoveEntityFramework()
.UseStoveDbContextEfTransactionStrategy()
.UseStoveTypedConnectionStringResolver());
}
/// <summary>
/// Uses the stove entity framework core.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="configurerAction"></param>
/// <returns></returns>
public static IIocBuilder UseStoveEntityFrameworkCore(
this IIocBuilder builder,
Func <IStoveEfCoreConfiguration, IStoveEfCoreConfiguration> configurerAction = null)
{
return(builder
.RegisterServices(r =>
{
var ormRegistrars = new List <ISecondaryOrmRegistrar>();
r.OnRegistering += (sender, args) =>
{
if (typeof(StoveDbContext).GetTypeInfo().IsAssignableFrom(args.ImplementationType))
{
EfCoreRepositoryRegistrar.RegisterRepositories(args.ImplementationType, builder);
ormRegistrars.Add(new EfCoreBasedSecondaryOrmRegistrar(builder, args.ImplementationType, EfCoreDbContextEntityFinder.GetEntityTypeInfos, EntityHelper.GetPrimaryKeyType));
args.ContainerBuilder.Properties[StoveConsts.OrmRegistrarContextKey] = ormRegistrars;
}
};
r.RegisterAssemblyByConvention(typeof(StoveEntityFrameworkCoreRegistrationExtensions).GetAssembly());
r.RegisterGeneric(typeof(IDbContextProvider <>), typeof(UnitOfWorkDbContextProvider <>));
r.Register <IUnitOfWorkDefaultOptions, UnitOfWorkDefaultOptions>(Lifetime.Singleton);
r.Register <IUnitOfWorkFilterExecuter, NullUnitOfWorkFilterExecuter>();
if (configurerAction != null)
{
r.Register(ctx => configurerAction);
}
})
.UseStoveEntityFrameworkCommon());
}
public static IIocBuilder UseStoveHangfire([NotNull] this IIocBuilder builder, [NotNull] Func <IStoveHangfireConfiguration, IStoveHangfireConfiguration> configureAction)
{
return(builder.RegisterServices(r =>
{
r.RegisterAssemblyByConvention(typeof(StoveHangfireRegistrationExtensions).GetAssembly());
r.Register(context => configureAction);
}));
}
/// <summary>
/// Uses the stove database context seed migration strategy.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="configurationAction">The configuration action.</param>
/// <returns></returns>
public static IIocBuilder UseStoveDbContextSeedMigrationStrategy(this IIocBuilder builder, Func <IStoveMigrationConfiguration, IStoveMigrationConfiguration> configurationAction)
{
return(builder.RegisterServices(r =>
{
r.Register(ctx => configurationAction);
r.Register <IMigrationStrategy, DbContextSeedMigrationStrategy>();
}));
}
public void RegisterRepositories(AutoRepositoryTypesAttribute defaultRepositoryTypes)
{
_iocBuilder.RegisterServices(r =>
{
r.RegisterGeneric(defaultRepositoryTypes.RepositoryInterface, defaultRepositoryTypes.RepositoryImplementation);
r.RegisterGeneric(defaultRepositoryTypes.RepositoryInterfaceWithPrimaryKey, defaultRepositoryTypes.RepositoryImplementationWithPrimaryKey);
});
}
public static IIocBuilder UseStoveDapper(this IIocBuilder builder)
{
builder.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()));
AutoRegisterRepositories(builder);
return(builder);
}
public static IIocBuilder UseStoveHangfire([NotNull] this IIocBuilder builder, [NotNull] Func <IStoveHangfireConfiguration, IStoveHangfireConfiguration> configureAction)
{
return(builder.RegisterServices(r =>
{
r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());
r.Register(context => configureAction);
}));
}
public static IIocBuilder UseStoveNLog([NotNull] this IIocBuilder builder)
{
return(builder.RegisterServices(r =>
{
r.RegisterAssemblyByConvention(typeof(StoveNLogRegistrationExtensions).GetAssembly());
r.Register <ILogger>(context => new StoveNLogLogger(LogManager.GetCurrentClassLogger()), Lifetime.Singleton);
r.UseBuilder(containerBuilder => containerBuilder.RegisterModule <NLogRegistrarModule>());
}));
}
public static IIocBuilder UseStove([NotNull] this IIocBuilder builder, [NotNull] Type starterBootstrapperType, bool autoUnitOfWorkInterceptionEnabled = false)
{
if (autoUnitOfWorkInterceptionEnabled)
{
builder.RegisterServices(r => r.UseBuilder(cb => cb.RegisterCallback(registry => registry.Registered += RegistryOnRegistered)));
}
Func <IStoveStartupConfiguration, IStoveStartupConfiguration> starterBootstrapperConfigurer = configuration =>
{
configuration.StarterBootstrapperType = starterBootstrapperType;
return(configuration);
};
builder.RegisterServices(r => r.Register(ctx => starterBootstrapperConfigurer));
RegisterStoveDefaults(builder);
return(builder);
}
public static IIocBuilder UseStoveMapster([NotNull] this IIocBuilder builder)
{
return(builder.RegisterServices(r =>
{
r.RegisterAssemblyByConvention(typeof(StoveMapsterRegistrationExtensions).GetAssembly());
r.Register <IStoveMapsterConfiguration, StoveMapsterConfiguration>(Lifetime.Singleton);
r.Register <IObjectMapper, MapsterObjectMapper>(Lifetime.Singleton);
}));
}
/// <summary>
/// Registers the ioc manager.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="iocManager">The ioc manager.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">iocManager</exception>
public static IIocBuilder RegisterIocManager(this IIocBuilder builder, IIocManager iocManager)
{
if (iocManager == null)
{
throw new ArgumentNullException(nameof(iocManager));
}
builder.RegisterServices(f => f.Register <IIocManager, IIocResolver>(iocManager, Lifetime.Singleton));
return(builder);
}
public static IIocBuilder UseStoveBackgroundJobs([NotNull] this IIocBuilder builder)
{
Func <IBackgroundJobConfiguration, IBackgroundJobConfiguration> configurer = configuration =>
{
configuration.IsJobExecutionEnabled = true;
return(configuration);
};
builder.RegisterServices(r => r.Register(ctx => configurer));
return(builder);
}
private IIocBuilder UseStoveRabbitMQInMemory(IIocBuilder builder)
{
builder
.RegisterServices(r =>
{
r.RegisterType <StoveRabbitMQBootstrapper>();
r.Register <IStoveRabbitMQConfiguration, StoveRabbitMQConfiguration>(Lifetime.Singleton);
r.Register <IMessageBus, StoveRabbitMQMessageBus>();
});
builder.RegisterServices(r => r.UseBuilder(cb => { cb.Register(ctx =>
{
return(Bus.Factory.CreateUsingInMemory(configurator =>
{
configurator.ReceiveEndpoint("test", endpointConfigurator => { endpointConfigurator.LoadFrom(ctx); });
}));
}).As <IBusControl>().As <IBus>().SingleInstance(); }));
return(builder);
}
public static IIocBuilder AddStoveDbContext <TDbContext>(this IIocBuilder builder,
Action <StoveDbContextConfiguration <TDbContext> > action) where TDbContext : DbContext
{
return(builder.RegisterServices(r => r.UseBuilder(cb =>
{
cb.RegisterInstance(new StoveDbContextConfigurerAction <TDbContext>(action))
.As <IStoveDbContextConfigurer <TDbContext> >()
.AsImplementedInterfaces()
.SingleInstance();
})));
}
public static IIocBuilder UseStoveSerilog(this IIocBuilder builder, Action <LoggerConfiguration> configureCallback)
{
return(builder.RegisterServices(r =>
{
var configuration = new LoggerConfiguration();
configureCallback(configuration);
r.RegisterAssemblyByConvention(typeof(StoveSerilogRegistrationExtensions).GetAssembly());
r.Register <Log.ILogger>(ctx => new StoveSerilogLogger(ctx.Resolver.Resolve <ILogger>()), Lifetime.Singleton);
r.Register <ILogger>(context => configuration.CreateLogger(), Lifetime.Singleton);
r.UseBuilder(containerBuilder => containerBuilder.RegisterModule <SerilogRegistrarModule>());
}));
}
public static IIocBuilder UseStoveRedisCaching(
[NotNull] this IIocBuilder builder,
[CanBeNull] Func <IStoveRedisCacheConfiguration, IStoveRedisCacheConfiguration> redisCacheConfigurer)
{
return(builder.RegisterServices(r =>
{
r.RegisterAssemblyByConvention(typeof(StoveRedisRegistrationExtensions).GetAssembly());
r.Register <IStoveRedisCacheConfiguration, StoveRedisCacheConfiguration>(Lifetime.Singleton);
r.RegisterType <StoveRedisCache>();
r.Register <ICacheManager, StoveRedisCacheManager>();
r.Register(ctx => redisCacheConfigurer);
}));
}
