/// <summary>
/// Register custom DataContext for a plugin
/// </summary>
/// <typeparam name="T">Class implementing IDbContext</typeparam>
/// <param name="dependencyRegistrar">Dependency registrar</param>
/// <param name="builder">Builder</param>
/// <param name="contextName">Context name</param>
public static void RegisterPluginDataContext <T>(this IDependencyRegister dependencyRegistrar,
ContainerBuilder builder, string contextName)
where T : IDbContext
{
//data layer
var dataSettingsManager = new DataSettingsManager();
var dataProviderSettings = dataSettingsManager.LoadSettings();
if (dataProviderSettings != null && dataProviderSettings.IsValid())
{
//register named context
builder.Register <IDbContext>(c => (IDbContext)Activator.CreateInstance(typeof(T), new object[] { dataProviderSettings.DataConnectionString }))
.Named <IDbContext>(contextName)
.InstancePerLifetimeScope();
builder.Register <T>(c => (T)Activator.CreateInstance(typeof(T), new object[] { dataProviderSettings.DataConnectionString }))
.InstancePerLifetimeScope();
}
else
{
//register named context
builder.Register <IDbContext>(c => (T)Activator.CreateInstance(typeof(T), new object[] { c.Resolve <DataSettings>().DataConnectionString }))
.Named <IDbContext>(contextName)
.InstancePerLifetimeScope();
builder.Register <T>(c => (T)Activator.CreateInstance(typeof(T), new object[] { c.Resolve <DataSettings>().DataConnectionString }))
.InstancePerLifetimeScope();
}
}
/// <summary>
/// Add the services of the modules.
/// </summary>
/// <param name="serviceCollection">Service collection</param>
public static void AddModuleServices(this IServiceCollection serviceCollection)
{
Type serviceType = typeof(IDependencyRegister);
IList <Assembly> moduleAssemblies = AssembliesContext.Instance.GetList();
if (moduleAssemblies is null)
{
return;
}
for (int i = 0; i < moduleAssemblies.Count; i++)
{
Type[] types = moduleAssemblies[i].GetTypes();
for (int j = 0; j < types.Length; j++)
{
Type type = types[j];
if (serviceType.IsAssignableFrom(type) && !type.GetTypeInfo().IsAbstract)
{
IDependencyRegister dependancyRegister = Activator.CreateInstance(type) as IDependencyRegister;
dependancyRegister.SetDependencyInjections(serviceCollection);
}
}
}
}
public void AutoPropertyInjection()
{
///创建注册器
IDependencyRegister register = container.CreateRegister();
///注册类型
register.RegisterType <IRepository <UserEntity>, UserRepository>();
register.RegisterType <IUserService, UserService>();
///注册自动属性
register.RegisterType <ILogger, Logger>().AsPropertyInjection();
///创建解析器
using (IDependencyResolver resolver = container.CreateResolver())
{
IRepository <UserEntity> userRepository = resolver.Resolve <IRepository <UserEntity> >();
var logger = ((UserRepository)userRepository).Logger;
Assert.IsInstanceOfType(logger, typeof(Logger));
Assert.AreNotEqual <ILogger>(logger, UnKownLogger.Instance);
IUserService useService = resolver.Resolve <IUserService>();
Assert.AreEqual <ILogger>(((UserService)useService).Logger, UnKownLogger.Instance);
IRepository <UserEntity> userRepository1 = resolver.Resolve <IRepository <UserEntity> >();
var logger1 = ((UserRepository)userRepository1).Logger;
Assert.IsInstanceOfType(logger1, typeof(Logger));
Assert.AreNotEqual <ILogger>(logger1, UnKownLogger.Instance);
}
}
public void Scoped()
{
///创建注册器
IDependencyRegister register = container.CreateRegister();
///注册瞬时生命周期的类型
register.RegisterType <IUserRepository, UserRepository>().AsScopedLifetime();
///创建解析器
using (IDependencyResolver resolver = container.CreateResolver())
{
IUserRepository userRepository1 = resolver.Resolve <IUserRepository>();
///创建作用域
using (IScopedResolver scoped = resolver.CreateScopedResolver())
{
IUserRepository scopedRepository1 = scoped.Resolve <IUserRepository>();
IUserRepository scopedRepository2 = scoped.Resolve <IUserRepository>();
Assert.AreNotEqual <IUserRepository>(userRepository1, scopedRepository1);
Assert.AreEqual <IUserRepository>(scopedRepository1, scopedRepository2);
///创建作用域
using (IScopedResolver scoped1 = scoped.CreateScopedResolver())
{
IUserRepository scopedRepository3 = scoped1.Resolve <IUserRepository>();
IUserRepository scopedRepository4 = scoped1.Resolve <IUserRepository>();
Assert.AreNotEqual <IUserRepository>(userRepository1, scopedRepository3);
Assert.AreNotEqual <IUserRepository>(scopedRepository1, scopedRepository3);
Assert.AreEqual <IUserRepository>(scopedRepository3, scopedRepository4);
}
}
}
}
public void SetUp(IDependencyRegister dependencyRegister)
{
dependencyRegister.AddScopedForMultiImplementation <IStreamService, MoviesStreamService>();
dependencyRegister.AddScopedForMultiImplementation <IStreamService, SeriesStreamService>();
dependencyRegister.AddScoped <IStreamFactory, StreamFactory>();
dependencyRegister.AddScoped <IValesService, ValesService>();
}
private static void RegisterPaymentProviders(IDependencyRegister host)
{
host.Register <IPaymentProviderRegistry>(CartConfiguration.PaymentProviderRegistry);
host.Register <PaymentProviderFactory, IPaymentProviderFactory>(ComponentLifestyle.Transient);
host.Register <MonerisCanadaPaymentProvider>(ComponentLifestyle.Transient);
host.Register <OnSitePOSPaymentProvider>(ComponentLifestyle.Transient);
}
public void Configure(IDependencyRegister register)
{
var section = ToolSection.Instance;
if (section == null)
{
throw new ConfigurationException("缺少 Projects.Tool 配直节信息。");
}
repositoryAssemblies = LoadAssemblies(section, "repository/assembly");
serviceAssemblies = LoadAssemblies(section, "service/assembly");
shardConfig = new ShardConfiguration(section);
metadataConfig = new MetadataConfiguration(repositoryAssemblies);
interceptorConfig = new InterceptorConfiguation(section);
repositoryConfig = new RepositoryConfiguation(repositoryAssemblies, register);
serviceConfig = new ServiceConfiguation(serviceAssemblies, register);
commandConfig = new CommandConfiguation(serviceAssemblies, register);
shardConfig.Load();
metadataConfig.Load();
interceptorConfig.Load();
repositoryConfig.Load();
serviceConfig.Load();
commandConfig.Load();
}
public static InstanceFactory CreateInstanceFactory(ZyRabbitOptions options, IDependencyRegister register, Func <IDependencyRegister, IDependencyResolver> resolverFunc)
{
register.AddZyRabbit(options);
var resolver = resolverFunc(register);
return(new InstanceFactory(resolver));
}
private static void RegisterShippingTrackingProviders(IDependencyRegister host)
{
host.Register <IShippingTrackingProviderRegistry>(CartConfiguration.ShippingTrackingProviderRegistry);
host.Register <ShippingTrackingProviderFactory, IShippingTrackingProviderFactory>(ComponentLifestyle.Transient);
host.Register <NullShippingTrackingProvider>(ComponentLifestyle.Transient);
CartConfiguration.ShippingTrackingProviderRegistry.RegisterProvider <NullShippingTrackingProvider>(CartConfiguration.DefaultShippingTrackingProviderName);
}
/// <summary>
/// 注册 Type
/// </summary>
public static IDependencyRegistration RegisterType(this IDependencyRegister dependencyRegister, Type serviceType)
{
if (serviceType == null)
{
throw new ArgumentNullException(nameof(serviceType));
}
return(dependencyRegister.RegisterType(serviceType, serviceType));
}
/// <summary>
/// 注册 实例
/// </summary>
public static IDependencyRegistration RegisterInstance(this IDependencyRegister dependencyRegister, Object instance)
{
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
return(dependencyRegister.RegisterInstance(instance.GetType(), instance));
}
/// <summary>
/// 注册 实例
/// </summary>
public static IDependencyRegistration RegisterInstance <TService>(this IDependencyRegister dependencyRegister, Object instance)
where TService : class
{
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
return(dependencyRegister.RegisterInstance(typeof(TService), instance));
}
/// <summary>
/// 注册 程序集
/// </summary>
public static IEnumerableRegistration RegisterAssembly(this IDependencyRegister dependencyRegister, Assembly assembly)
{
if (assembly == null)
{
throw new ArgumentNullException(nameof(assembly));
}
var enumerableConfiguration = DependencyRegistrationFactory.ForAssembly(assembly);
return(RegisterCollection(dependencyRegister, enumerableConfiguration));
}
public MongoDBWriteDataTest()
{
_dependencyRegister = new UnityDependencyRegister();
ApplicationConfig.SetDependencyResolver(_dependencyRegister.GetResolver());
_dependencyRegister.Register <IDBService, MongoDBService>();
_dependencyRegister.Register <IJSONValidator, JSONValidator>();
_dependencyRegister.RegisterInstance <IAppSettingService>(AppSettingService.Instance);
_dependencyRegister.Register <IEncryption, EncryptionService>();
_dependencyRegister.RegisterInstance <IViewEngine>(RazorTemplateEngine.GetEngine());
_dependencyRegister.Register <IKeyValueStorage, FileKeyValueFileStorage>();
}
public void ConfigureDependencies(IServiceCollection serviceCollection)
{
foreach (System.Type registry in GetTypesForSearchRegistries())
{
IEnumerable <System.Type> interfaces = ((System.Reflection.TypeInfo)registry).ImplementedInterfaces;
if (interfaces.Any(i => i == typeof(IDependencyRegister)))
{
IDependencyRegister dependecy = (IDependencyRegister)Activator.CreateInstance(registry);
dependecy.ConfigureDependencies(serviceCollection);
}
}
}
public static void RegisterTypes(IUnityContainer container)
{
container.RegisterInstance(container);
ITypeFinder typeFinder = new WebTypeFinder();
IEnumerable <Type> registerTypes = typeFinder.FindClassesOfType <IDependencyRegister>();
foreach (Type registerType in registerTypes)
{
IDependencyRegister register = (IDependencyRegister)Activator.CreateInstance(registerType);
register.RegisterTypes(container);
}
}
private static IDependencyRegistration RegisterRegistration(IDependencyRegister dependencyRegister, IDependencyRegistration registerConfiguration)
{
if (dependencyRegister == null)
{
throw new ArgumentNullException(nameof(IDependencyRegister));
}
if (registerConfiguration == null)
{
throw new ArgumentNullException(nameof(registerConfiguration));
}
dependencyRegister.RegisterEntry(((DependencyRegistration)registerConfiguration).Entry);
return(registerConfiguration);
}
/// <summary>
/// 注册程序集中使实现特定接口或基类的类型作为依赖服务
/// </summary>
/// <exception cref="ArgumentNullException"></exception>
public static IEnumerableRegistration RegisterAssembly(this IDependencyRegister dependencyRegister, Type baseType, params Assembly[] assemblys)
{
if (baseType == null)
{
throw new ArgumentNullException(nameof(baseType));
}
if (assemblys == null)
{
throw new ArgumentNullException(nameof(assemblys));
}
var enumerableConfiguration = DependencyRegistrationFactory.ForAssembly(assemblys, baseType);
return(RegisterCollection(dependencyRegister, enumerableConfiguration));
}
/// <summary>
/// 注册程序集中使用特定命名约定的类型作为依赖服务
/// </summary>
/// <exception cref="ArgumentNullException"></exception>
public static IEnumerableRegistration RegisterAssembly(this IDependencyRegister dependencyRegister, string name, params Assembly[] assemblys)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
if (assemblys == null)
{
throw new ArgumentNullException(nameof(assemblys));
}
var enumerableConfiguration = DependencyRegistrationFactory.ForAssembly(assemblys, name);
return(RegisterCollection(dependencyRegister, enumerableConfiguration));
}
/// <summary>
/// 注册类型和返回实现实例的委托为依赖服务
/// </summary>
/// <exception cref="ArgumentNullException"></exception>
public static ILifetimeRegistration <ILifetimeRegistration> RegisterDelegate <TService, TImplementation>(
this IDependencyRegister dependencyRegister,
Func <IDependencyResolver, TImplementation> implementationDelegate)
where TImplementation : class, TService
{
if (implementationDelegate == null)
{
throw new ArgumentNullException(nameof(implementationDelegate));
}
var registerConfiguration = DependencyRegistrationFactory.ForDelegate(typeof(TService),
implementationDelegate);
return((DependencyRegistration)RegisterRegistration(dependencyRegister, registerConfiguration));
}
/// <summary>
/// 注册 实例
/// </summary>
public static IDependencyRegistration RegisterInstance(this IDependencyRegister dependencyRegister, Type serviceType, Object implementationInstance)
{
if (serviceType == null)
{
throw new ArgumentNullException(nameof(serviceType));
}
if (implementationInstance == null)
{
throw new ArgumentNullException(nameof(implementationInstance));
}
var registerConfiguration = DependencyRegistrationFactory.ForInstance(serviceType, implementationInstance);
return(RegisterRegistration(dependencyRegister, registerConfiguration));
}
public void RegisterDelegate()
{
///创建注册器
IDependencyRegister register = container.CreateRegister();
///注册委托
register.RegisterDelegate <IUserRepository, UserRepository>(resolver => new UserRepository());
///创建解析器
using (IDependencyResolver resolver = container.CreateResolver())
{
IUserRepository userRepository = resolver.Resolve <IUserRepository>();
Assert.IsNotNull(userRepository);
Assert.IsInstanceOfType(userRepository, typeof(IUserRepository));
}
}
public void RegisterInstance()
{
///创建注册器
IDependencyRegister register = container.CreateRegister();
///注册类型的实例
UserRepository instance = new UserRepository();
register.RegisterInstance(typeof(IUserRepository), instance);
///创建解析器
using (IDependencyResolver resolver = container.CreateResolver())
{
IUserRepository userRepository = resolver.Resolve <IUserRepository>();
Assert.IsNotNull(userRepository);
Assert.IsInstanceOfType(userRepository, typeof(IUserRepository));
}
}
/// <summary>
/// 注册 委托
/// </summary>
public static IDependencyRegistration RegisterDelegate <TImplementation>(this IDependencyRegister dependencyRegister, Type serviceType, Func <IDependencyResolver, TImplementation> implementationDelegate)
where TImplementation : class
{
if (serviceType == null)
{
throw new ArgumentNullException(nameof(serviceType));
}
if (implementationDelegate == null)
{
throw new ArgumentNullException(nameof(implementationDelegate));
}
var registerConfiguration = DependencyRegistrationFactory.ForDelegate(serviceType, implementationDelegate);
return(RegisterRegistration(dependencyRegister, registerConfiguration));
}
public void RegisterBaseType()
{
///创建注册器
IDependencyRegister register = container.CreateRegister();
///注册实现特定接口或基类的类型
var assembly = register.RegisterAssembly <IDependency>(Assembly.GetExecutingAssembly());
using (IDependencyResolver resolver = container.CreateResolver())
{
var results = resolver.ResolveAll <IDependency>();
foreach (var value in results)
{
Assert.IsNotNull(value);
Assert.IsInstanceOfType(value, typeof(IDependency));
}
}
}
private static IEnumerableRegistration RegisterCollection(IDependencyRegister dependencyRegister, IEnumerableRegistration configurationCollections)
{
if (dependencyRegister == null)
{
throw new ArgumentNullException(nameof(IDependencyRegister));
}
if (configurationCollections == null)
{
throw new ArgumentNullException(nameof(configurationCollections));
}
foreach (var configuration in configurationCollections)
{
RegisterRegistration(dependencyRegister, configuration);
}
return(configurationCollections);
}
public void RegisterNamed()
{
///创建注册器
IDependencyRegister register = container.CreateRegister();
///注册程序集中符合约定名称的类型
register.RegisterAssembly("Repository", Assembly.GetExecutingAssembly());
///创建解析器
using (IDependencyResolver resolver = container.CreateResolver())
{
var results = resolver.ResolveAll <IRepository <UserEntity> >();
foreach (var value in results)
{
Assert.IsNotNull(value);
Assert.IsInstanceOfType(value, typeof(IRepository <UserEntity>));
}
}
}
public void RegisterGeneric()
{
///创建注册器
IDependencyRegister register = container.CreateRegister();
///注册实现特定泛型类型定义IRepository<>的类型
register.RegisterAssembly(typeof(IRepository <>), Assembly.GetExecutingAssembly());
///创建解析器
using (IDependencyResolver resolver = container.CreateResolver())
{
///解析实现特定泛型类型定义IRepository<>的类型
var results = resolver.ResolveAll(typeof(IRepository <>));
foreach (var value in results)
{
Assert.IsNotNull(value);
Assert.IsInstanceOfType(value, typeof(IRepository <UserEntity>));
}
}
}
public void Constructor()
{
///创建注册器
IDependencyRegister register = container.CreateRegister();
///注册类型
register.RegisterType <IRepository <UserEntity>, UserRepository>();
register.RegisterType <IUserService, UserService>();
///创建解析器
using (IDependencyResolver resolver = container.CreateResolver())
{
IUserService service = resolver.Resolve <IUserService>();
UserEntity entity = service.GetById(1);
Assert.IsNotNull(entity);
Assert.AreEqual(entity.Id, 1);
}
}
public void ResolverCallSiteExtensions()
{
///创建注册器
IDependencyRegister register = container.CreateRegister();
///注册类型
register.RegisterType <IRepository <UserEntity>, UserRepository>();
register.RegisterType <IUserService, UserService>();
///创建解析器
using (IDependencyResolver resolver = container.CreateResolver())
{
///清除默认解析器
resolver.RemoveAllCallSites();
///添加自定义解析器
resolver.AddCallSite(new CustomResolverCallSite());
IUserService service = resolver.Resolve <IUserService>();
Assert.IsNotNull(service);
}
}
