/// <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); } }