public static void RegisterForDbContext(Type dbContextType, IIocManager iocManager)
        {
            var repositoryType = dbContextType.Assembly.GetTypes().Where(type => !string.IsNullOrEmpty(type.Namespace))
                .Where(type => type.BaseType != null && type.BaseType.IsGenericType && (type.BaseType.GetGenericTypeDefinition() == typeof(IRepository<>) || type.BaseType.GetGenericTypeDefinition() == typeof(IRepository<,>) || type.BaseType.GetGenericTypeDefinition() == typeof(EfRepositoryBase<,>) || type.BaseType.GetGenericTypeDefinition() == typeof(EfRepositoryBase<,,>)));

            foreach (var entityType in dbContextType.GetEntityTypes())//从dataset中获取所有的实体
            {
                foreach (var interfaceType in entityType.GetInterfaces())//获取所有实体实现的接口
                {
                    if (interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(IEntity<>))
                    {
                        var primaryKeyType = interfaceType.GenericTypeArguments[0];//获取所有的实体的主键

                        foreach (var maprepositoryType in repositoryType)
                        {
                            if (!iocManager.IsRegistered(maprepositoryType))
                            {
                                var implType = maprepositoryType.GetGenericArguments().Length == 2
                                            ? maprepositoryType.MakeGenericType(entityType, primaryKeyType)
                                            : maprepositoryType.MakeGenericType(dbContextType, entityType, primaryKeyType);
                                iocManager.Register(
                                maprepositoryType,
                                implType,
                                DependencyLifeStyle.Transient
                                );
                            }
                        }
                    }
                }

            }
        }
        public static void Initialize(IIocManager manager,List<Assembly> assemblys)
        {
            assemblys.ForEach(m =>
                {
                    ////多实例
                    //manager.IocContainer.Register(
                    //    Classes.FromAssembly(m)
                    //        .IncludeNonPublicTypes()
                    //        .BasedOn<IMultipleDependency>()
                    //        .WithService.Self()
                    //        .WithService.DefaultInterfaces()
                    //        .LifestyleTransient()
                    //    );

                    ////单例
                    //manager.IocContainer.Register(
                    //    Classes.FromAssembly(m)
                    //        .IncludeNonPublicTypes()
                    //        .BasedOn<ISingleDependency>()
                    //        .WithService.Self()
                    //        .WithService.DefaultInterfaces()
                    //        .LifestyleSingleton()
                    //    );

                    ////拦截器
                    //manager.IocContainer.Register(
                    //    Classes.FromAssembly(m)
                    //        .IncludeNonPublicTypes()
                    //        .BasedOn<IInterceptor>()
                    //        .WithService.Self()
                    //        .LifestyleTransient()
                    //    );
                    Registrants.ForEach(r => r(m));
                });
        }
 public DefaultModuleManager(IIocManager iocManager, IModuleFinder moduleFinder, IConfigurationManager configurationManager)
 {
     _modules = new ModuleCollection();
     _iocManager = iocManager;
     _moduleFinder = moduleFinder;
     _configurationManager = configurationManager;
 }
        public AbpNHibernateInterceptor(IIocManager iocManager)
        {
            _iocManager = iocManager;

            _abpSession =
                new Lazy<IAbpSession>(
                    () => _iocManager.IsRegistered(typeof(IAbpSession))
                        ? _iocManager.Resolve<IAbpSession>()
                        : NullAbpSession.Instance,
                    isThreadSafe: true
                    );
            _guidGenerator =
                new Lazy<IGuidGenerator>(
                    () => _iocManager.IsRegistered(typeof(IGuidGenerator))
                        ? _iocManager.Resolve<IGuidGenerator>()
                        : SequentialGuidGenerator.Instance,
                    isThreadSafe: true
                    );

            _eventBus =
                new Lazy<IEventBus>(
                    () => _iocManager.IsRegistered(typeof(IEventBus))
                        ? _iocManager.Resolve<IEventBus>()
                        : NullEventBus.Instance,
                    isThreadSafe: true
                );
        }
Exemple #5
0
        /// <summary>
        /// Constructor.
        /// </summary>
        public PermissionManager(IIocManager iocManager, IAuthorizationConfiguration authorizationConfiguration)
        {
            _iocManager = iocManager;
            _authorizationConfiguration = authorizationConfiguration;

            AbpSession = NullAbpSession.Instance;
        }
        public static void RegisterForDbContext(Type dbContextType, IIocManager iocManager)
        {
            var autoRepositoryAttr = dbContextType.GetSingleAttributeOrNull<AutoRepositoryTypesAttribute>();
            if (autoRepositoryAttr == null)
            {
                autoRepositoryAttr = AutoRepositoryTypesAttribute.Default;
            }

            foreach (var entityType in dbContextType.GetEntityTypes())
            {

                var genericRepositoryType = autoRepositoryAttr.RepositoryInterface.MakeGenericType(entityType);
                if (!iocManager.IsRegistered(genericRepositoryType))
                {
                    var implType = autoRepositoryAttr.RepositoryImplementation.GetGenericArguments().Length == 1
                            ? autoRepositoryAttr.RepositoryImplementation.MakeGenericType(entityType)
                            : autoRepositoryAttr.RepositoryImplementation.MakeGenericType(dbContextType, entityType);

                    iocManager.Register(
                        genericRepositoryType,
                        implType,
                        DependencyLifeStyle.Multiple
                        );
                }

            }
        }
 public AbpModuleManager(IIocManager iocManager, IModuleFinder moduleFinder)
 {
     _modules = new AbpModuleCollection();
     _iocManager = iocManager;
     _moduleFinder = moduleFinder;
     Logger = NullLogger.Instance;
 }
        public LanguageManagementConfig(IIocManager iocManager, IAbpStartupConfiguration configuration)
        {
            _iocManager = iocManager;
            _configuration = configuration;

            Logger = NullLogger.Instance;
        }
 private static void Test_Way_2(IIocManager iocManager)
 {
     using (var tester = iocManager.ResolveAsDisposable<Tester>())
     {
         tester.Object.Test();
     }
 }
        public static void RegisterForDbContext(Type dbContextType, IIocManager iocManager)
        {
            foreach (var entityType in dbContextType.GetEntityTypes())
            {
                foreach (var interfaceType in entityType.GetInterfaces())
                {
                    if (interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(IEntity<>))
                    {
                        var primaryKeyType = interfaceType.GenericTypeArguments[0];
                        if (primaryKeyType == typeof(Guid))
                        {
                            var genericRepositoryType = typeof(IRepository<>).MakeGenericType(entityType);
                            if (!iocManager.IsRegistered(genericRepositoryType))
                            {
                                iocManager.Register(
                                    genericRepositoryType,
                                    typeof(EfRepositoryBase<,>).MakeGenericType(dbContextType, entityType),
                                    DependencyLifeStyle.Transient
                                    );
                            }
                        }

                        var genericRepositoryTypeWithPrimaryKey = typeof(IRepository<,>).MakeGenericType(entityType, primaryKeyType);
                        if (!iocManager.IsRegistered(genericRepositoryTypeWithPrimaryKey))
                        {
                            iocManager.Register(
                                genericRepositoryTypeWithPrimaryKey,
                                typeof(EfRepositoryBase<,,>).MakeGenericType(dbContextType, entityType, primaryKeyType),
                                DependencyLifeStyle.Transient
                                );
                        }
                    }
                }
            }
        }
 public AbpModuleManager(IIocManager iocManager, IAbpPlugInManager abpPlugInManager)
 {
     _modules = new AbpModuleCollection();
     _iocManager = iocManager;
     _abpPlugInManager = abpPlugInManager;
     Logger = NullLogger.Instance;
 }
 private static void Test_Way_3(IIocManager iocManager)
 {
     iocManager.Using<Tester>(tester =>
     {
         tester.Test();
     });
 }
        private static void Test_Way_1(IIocManager iocManager)
        {
            var tester = iocManager.Resolve<Tester>();

            tester.Test();

            iocManager.Release(tester);
        }
 public UnitOfWorkManager(
     IIocManager iocManager,
     IUnitOfWorkProvider currentUnitOfWorkProvider,
     IUnitOfWorkDefaultOptions defaultOptions)
 {
     _iocManager = iocManager;
     _currentUnitOfWorkProvider = currentUnitOfWorkProvider;
     _defaultOptions = defaultOptions;
 }
 public AbpNHibernateInterceptor(IIocManager iocManager)
 {
     _iocManager = iocManager;
     _abpSession =
         new Lazy<IAbpSession>(
             () => _iocManager.IsRegistered(typeof(IAbpSession))
                 ? _iocManager.Resolve<IAbpSession>()
                 : NullAbpSession.Instance
             );
 }
 /// <summary>
 /// Constructor.
 /// </summary>
 public DynamicAuthorizationManager(
     IIocManager iocManager,
     IPermissionDefinitionContext permissionContext,
     IAuthorizationConfiguration authorizationConfiguration
     )
 {
     _iocManager = iocManager;
     _permissionContext = permissionContext;
     _authorizationConfiguration = authorizationConfiguration;
 }
Exemple #17
0
        public static void RegisterForService(IIocManager iocManager)
        {
            var typetoMap = Assembly.GetExecutingAssembly().GetTypes()
                .Where(type => !string.IsNullOrEmpty(type.Namespace))
                .Where(type => type.BaseType != null && type.BaseType.IsInterface && type.BaseType == typeof(IApplicationService));

            foreach (var mapType in typetoMap)
            {
                iocManager.Register(mapType, DependencyLifeStyle.Transient);
            }
        }
        /// <summary>
        /// Constructor.
        /// </summary>
        public PermissionManager(IIocManager iocManager, IAuthorizationConfiguration authorizationConfiguration)
        {
            PermissionGrantStore = NullPermissionGrantStore.Instance;
            Logger = NullLogger.Instance;

            _iocManager = iocManager;
            _authorizationConfiguration = authorizationConfiguration;

            _rootGroups = new Dictionary<string, PermissionGroup>();
            _permissions = new PermissionDictionary();
        }
Exemple #19
0
        static ServiceManager()
        {
            ServiceContext = new ServiceContext();
            ServiceContext.Scheduler = null;
            ServiceContext.WcfHost = null;
            ServiceContext.ProgressInfoManager = ProgressInfoManager.Instance;

            iocManager = IocManager.Instance;

            Initialize();
        }
 public static void Initialize(IIocManager iocManager)
 {
     var auditingConfiguration = iocManager.Resolve<IAuditingConfiguration>();
     iocManager.IocContainer.Kernel.ComponentRegistered += (key, handler) =>
     {
         if (ShouldIntercept(auditingConfiguration, handler.ComponentModel.Implementation))
         {
             handler.ComponentModel.Interceptors.Add(new InterceptorReference(typeof(AuditingInterceptor)));
         }
     };
 }
        public static void Initialize(IIocManager iocManager)
        {
            _auditingConfiguration = iocManager.Resolve<IAuditingConfiguration>();

            if (!_auditingConfiguration.IsEnabled)
            {
                return;
            }

            iocManager.IocContainer.Kernel.ComponentRegistered += Kernel_ComponentRegistered;
        }
        /// <summary>
        /// Constructor.
        /// </summary>
        public PermissionManager(
            IIocManager iocManager, 
            IAuthorizationConfiguration authorizationConfiguration,
            FeatureDependencyContext featureDependencyContext
            )
        {
            _iocManager = iocManager;
            _authorizationConfiguration = authorizationConfiguration;
            _featureDependencyContext = featureDependencyContext;

            AbpSession = NullAbpSession.Instance;
        }
        public static void RegisterForDbContext(Type dbContextType, IIocManager iocManager)
        {
            //获取已经标记的 "AutoRepositoryTypesAttribute" 属性
            var autoRepositoryAttr = dbContextType.GetSingleAttributeOrNull<AutoRepositoryTypesAttribute>();
            //没有标记"AutoRepositoryTypesAttribute"属性的"DbContext"采用默认AutoRepositoryTypesAttribute属性
            if (autoRepositoryAttr == null)
            {
                autoRepositoryAttr = AutoRepositoryTypesAttribute.Default;
            }
            //获取DbSet或者IDbSet属性
            foreach (var entityType in dbContextType.GetEntityTypes())
            {                
                foreach (var interfaceType in entityType.GetInterfaces())
                {
                    if (interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(IEntity<>))
                    {
                        var primaryKeyType = interfaceType.GenericTypeArguments[0];
                        if (primaryKeyType == typeof(int))
                        {
                            var genericRepositoryType = autoRepositoryAttr.RepositoryInterface.MakeGenericType(entityType);
                            if (!iocManager.IsRegistered(genericRepositoryType))
                            {
                                var implType = autoRepositoryAttr.RepositoryImplementation.GetGenericArguments().Length == 1
                                        ? autoRepositoryAttr.RepositoryImplementation.MakeGenericType(entityType)
                                        : autoRepositoryAttr.RepositoryImplementation.MakeGenericType(dbContextType, entityType);
                                
                                iocManager.Register(
                                    genericRepositoryType,
                                    implType,
                                    DependencyLifeStyle.Transient
                                    );
                            }
                        }

                        var genericRepositoryTypeWithPrimaryKey = autoRepositoryAttr.RepositoryInterfaceWithPrimaryKey.MakeGenericType(entityType, primaryKeyType);
                        if (!iocManager.IsRegistered(genericRepositoryTypeWithPrimaryKey))
                        {
                            var implType = autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.GetGenericArguments().Length == 2
                                        ? autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(entityType, primaryKeyType)
                                        : autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(dbContextType, entityType, primaryKeyType);

                            iocManager.Register(
                                genericRepositoryTypeWithPrimaryKey,
                                implType,
                                DependencyLifeStyle.Transient
                                );
                        }
                    }
                }
            }
        }
        public static void Initialize(IIocManager manager, List<Assembly> assemblys)
        {
            assemblys.ForEach(m =>
            {  // controller
                manager.IocContainer.Register(
                    Classes.FromAssembly(m)
                        .IncludeNonPublicTypes()
                        .BasedOn<System.Web.Mvc.Controller>()
                        .WithService.Self()
                        .WithService.DefaultInterfaces()
                        .LifestyleTransient()
                    );

            });
        }
        public BdfNHibernateInterceptor(IIocManager iocManager)
        {
            _iocManager = iocManager;
             _BdfSession =
                new Lazy<IBdfSession>(
                    () => _iocManager.IsRegistered(typeof(IBdfSession))
                        ? _iocManager.Resolve<IBdfSession>()
                        : NullBdfSession.Instance
                    );

            EntityChangedEventHelper =
                _iocManager.IsRegistered(typeof (IEntityChangedEventHelper))
                    ? _iocManager.Resolve<IEntityChangedEventHelper>()
                    : NullEntityChangedEventHelper.Instance;
        }
Exemple #26
0
        //核心部分的注册
        public void Init(IIocManager iocManager)
        {
            var container = iocManager.Container;
            var builder = new ContainerBuilder();

            var assemblies = AppDomain.CurrentDomain.GetAssemblies();

            //所有注册器
            var finder = new WebAppTypeFinder();
            var allRegistrars = finder.FindClassOfType(typeof(IDependencyRegistrar));
            foreach (var registrar in allRegistrars)
                (Activator.CreateInstance(registrar) as IDependencyRegistrar).Register(builder);

            //织入点配置
            var proxyOption = new ProxyGenerationOptions()
            {
                Selector = new InterceptorSelector()
            };

            //注册所有拦截器
            builder.RegisterAssemblyTypes(assemblies)
                .Where(type => type.IsAssignableTo<Castle.DynamicProxy.IInterceptor>());

            //注册单例
            builder.RegisterAssemblyTypes(assemblies)
                .EnableInterfaceInterceptors(proxyOption)
                .Where(type => type.IsAssignableTo<ISingletonDependency>())
                .AsImplementedInterfaces()
                //.Named<ISingletonDependency>(type => type.Name)
                .SingleInstance();

            //注册瞬态
            builder.RegisterAssemblyTypes(assemblies)
                .Where(type => type.IsAssignableTo<ITransientDependency>())
                .AsImplementedInterfaces()
                .InstancePerLifetimeScope()
                .EnableInterfaceInterceptors(proxyOption);

            builder.RegisterType<DefaultEventBus>().Named<IEventBus>(BusEnum.DefaultBus.GetName());
            builder.RegisterType<MsmqEventBus>().Named<IEventBus>(BusEnum.MsmqBus.GetName());

            builder.RegisterInstance<IContainer>(container);
            builder.RegisterInstance<IIocResolver>(iocManager);

            builder.Update(container);
        }
        public static void RegisterForDbContext(Type dbContextType, IIocManager iocManager)
        {
            var autoRepositoryAttr = dbContextType.GetSingleAttributeOrNull<AutoRepositoryTypesAttribute>() ??
                                     AutoRepositoryTypesAttribute.Default;

            foreach (var entityType in dbContextType.GetEntityTypes())
            {
                foreach (var interfaceType in entityType.GetInterfaces())
                {
                    if (!interfaceType.IsGenericType || interfaceType.GetGenericTypeDefinition() != typeof (IEntity<>))
                        continue;
                    var primaryKeyType = interfaceType.GenericTypeArguments[0];
                    if (primaryKeyType == typeof(int))
                    {
                        var genericRepositoryType = autoRepositoryAttr.RepositoryInterface.MakeGenericType(entityType);
                        if (!iocManager.IsRegistered(genericRepositoryType))
                        {
                            var implType = autoRepositoryAttr.RepositoryImplementation.GetGenericArguments().Length == 1
                                ? autoRepositoryAttr.RepositoryImplementation.MakeGenericType(entityType)
                                : autoRepositoryAttr.RepositoryImplementation.MakeGenericType(dbContextType, entityType);

                            iocManager.Register(
                                genericRepositoryType,
                                implType,
                                DependencyLifeStyle.Transient
                                );
                        }
                    }

                    var genericRepositoryTypeWithPrimaryKey = autoRepositoryAttr.RepositoryInterfaceWithPrimaryKey.MakeGenericType(entityType, primaryKeyType);
                    if (!iocManager.IsRegistered(genericRepositoryTypeWithPrimaryKey))
                    {
                        var implType = autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.GetGenericArguments().Length == 2
                            ? autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(entityType, primaryKeyType)
                            : autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(dbContextType, entityType, primaryKeyType);

                        iocManager.Register(
                            genericRepositoryTypeWithPrimaryKey,
                            implType,
                            DependencyLifeStyle.Transient
                            );
                    }
                }
            }
        }
        /// <summary>
        /// 注册数据上下文
        /// </summary>
        /// <param name="dbContextType">数据上下文类型</param>
        /// <param name="iocManager">IOC管理</param>
        public static void RegisterForDbContext(Type dbContextType, IIocManager iocManager)
        {
            //获取AutoRepositoryTypesAttribute自动仓储类型自定义属性的类型
            var autoRepositoryAttr = dbContextType.GetSingleAttributeOrNull<AutoRepositoryTypesAttribute>();
            if (autoRepositoryAttr == null)
            {
                autoRepositoryAttr = AutoRepositoryTypesAttribute.Default;
            }

            foreach (var entityType in dbContextType.GetEntityTypes())
            {
                var primaryKeyType = EntityHelper.GetPrimaryKeyType(entityType);
                if (primaryKeyType == typeof(int))
                {
                    var genericRepositoryType = autoRepositoryAttr.RepositoryInterface.MakeGenericType(entityType);
                    if (!iocManager.IsRegistered(genericRepositoryType))
                    {
                        var implType = autoRepositoryAttr.RepositoryImplementation.GetGenericArguments().Length == 1
                                ? autoRepositoryAttr.RepositoryImplementation.MakeGenericType(entityType)
                                : autoRepositoryAttr.RepositoryImplementation.MakeGenericType(dbContextType, entityType);

                        iocManager.Register(
                            genericRepositoryType,
                            implType,
                            DependencyLifeStyle.Transient
                            );
                    }
                }

                var genericRepositoryTypeWithPrimaryKey = autoRepositoryAttr.RepositoryInterfaceWithPrimaryKey.MakeGenericType(entityType, primaryKeyType);
                if (!iocManager.IsRegistered(genericRepositoryTypeWithPrimaryKey))
                {
                    var implType = autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.GetGenericArguments().Length == 2
                                ? autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(entityType, primaryKeyType)
                                : autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(dbContextType, entityType, primaryKeyType);

                    iocManager.Register(
                        genericRepositoryTypeWithPrimaryKey,
                        implType,
                        DependencyLifeStyle.Transient
                        );
                }
            }
        }
Exemple #29
0
        public static void Register(IIocManager iocManager)
        {
            RegisterIdentity(iocManager);

            var builder = new DbContextOptionsBuilder <ProjectDbContext>();

            var inMemorySqlite = new SqliteConnection("Data Source=:memory:");

            builder.UseSqlite(inMemorySqlite);

            iocManager.IocContainer.Register(
                Component
                .For <DbContextOptions <ProjectDbContext> >()
                .Instance(builder.Options)
                .LifestyleSingleton()
                );

            inMemorySqlite.Open();

            new ProjectDbContext(builder.Options).Database.EnsureCreated();
        }
        private void RegisterGenericRepositories(IIocManager manager)
        {
            var dbContextTypes =
                TypeFinder.Find(type =>
                    type.IsPublic &&
                    !type.IsAbstract &&
                    type.IsClass &&
                    typeof(MongoDbContext).IsAssignableFrom(type)
                    );

            if (dbContextTypes.Count() <= 0)
            {
                return;   // 没有 mongodbContext

            }
            //dbContextTypes.ToList().ForEach(m => IocManager.Register(m));
            foreach (var dbContextType in dbContextTypes)
            {
                MongoDbGenericRepositoryRegistrar.RegisterForDbContext(dbContextType, manager);
            }
        }
         private void RegisterGenericRepositories(IIocManager manager)
         {
             var dbContextTypes =
                 TypeFinder.Find(type =>
                     type.IsPublic &&
                     !type.IsAbstract &&
                     type.IsClass &&
                     typeof(DbContext).IsAssignableFrom(type)
                     );

             if (dbContextTypes.Count() <= 0)
             {
                 throw new Exception("No class found derived from DbContext.");

             }
             dbContextTypes.ToList().ForEach(m => IocManager.Register(m,DependencyLifeStyle.Multiple));
             foreach (var dbContextType in dbContextTypes)
             {
                 EntityFrameworkGenericRepositoryRegistrar.RegisterForDbContext(dbContextType, manager);
             }
         }
Exemple #32
0
        public static void Register(IIocManager iocManager)
        {
            var services = new ServiceCollection();

            IdentityRegistrar.Register(services);

            services.AddEntityFrameworkInMemoryDatabase();

            var serviceProvider = WindsorRegistrationHelper.CreateServiceProvider(iocManager.IocContainer, services);

            var builder = new DbContextOptionsBuilder <MySuperStatsDbContext>();

            builder.UseInMemoryDatabase(Guid.NewGuid().ToString()).UseInternalServiceProvider(serviceProvider);

            iocManager.IocContainer.Register(
                Component
                .For <DbContextOptions <MySuperStatsDbContext> >()
                .Instance(builder.Options)
                .LifestyleSingleton()
                );
        }
Exemple #33
0
        public virtual void RegisterRepositories(IIocManager iocManager, AutoRepositoryTypesAttribute defaultRepositoryTypes)
        {
            AutoRepositoryTypesAttribute autoRepositoryAttr = _dbContextType.GetTypeInfo().GetSingleAttributeOrNull <AutoRepositoryTypesAttribute>()
                                                              ?? defaultRepositoryTypes;

            foreach (EntityTypeInfo entityTypeInfo in _dbContextEntityFinder.GetEntityTypeInfos(_dbContextType))
            {
                Type primaryKeyType = EntityHelper.GetPrimaryKeyType(entityTypeInfo.EntityType);
                if (primaryKeyType == typeof(int))
                {
                    Type genericRepositoryType = autoRepositoryAttr.RepositoryInterface.MakeGenericType(entityTypeInfo.EntityType);
                    if (!iocManager.IsRegistered(genericRepositoryType))
                    {
                        Type implType = autoRepositoryAttr.RepositoryImplementation.GetTypeInfo().GetGenericArguments().Length == 1
                            ? autoRepositoryAttr.RepositoryImplementation.MakeGenericType(entityTypeInfo.EntityType)
                            : autoRepositoryAttr.RepositoryImplementation.MakeGenericType(entityTypeInfo.DeclaringType, entityTypeInfo.EntityType);

                        iocManager.Register(
                            genericRepositoryType,
                            implType,
                            DependencyLifeStyle.Transient
                            );
                    }
                }

                Type genericRepositoryTypeWithPrimaryKey = autoRepositoryAttr.RepositoryInterfaceWithPrimaryKey.MakeGenericType(entityTypeInfo.EntityType, primaryKeyType);
                if (!iocManager.IsRegistered(genericRepositoryTypeWithPrimaryKey))
                {
                    Type implType = autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.GetTypeInfo().GetGenericArguments().Length == 2
                        ? autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(entityTypeInfo.EntityType, primaryKeyType)
                        : autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(entityTypeInfo.DeclaringType, entityTypeInfo.EntityType, primaryKeyType);

                    iocManager.Register(
                        genericRepositoryTypeWithPrimaryKey,
                        implType,
                        DependencyLifeStyle.Transient
                        );
                }
            }
        }
Exemple #34
0
        /// <summary>
        ///     配置微信小程序
        /// </summary>
        public static void Config(ILogger logger, IIocManager iocManager, IConfigurationRoot config, ISettingManager settingManager)
        {
            //日志函数
            void LogAction(string tag, string message)
            {
                if (tag.Equals("error", StringComparison.CurrentCultureIgnoreCase))
                {
                    logger.Error(message);
                }
                else
                {
                    logger.Debug(message);
                }
            }

            var configInfo = new DefaultMiniProgramConfig
            {
                MiniProgramAppId     = config["WeChat:MiniProgram:AppId"],
                MiniProgramAppSecret = config["WeChat:MiniProgram:AppSecret"]
            };

            //从用户设置读取配置
            if (Convert.ToBoolean(settingManager.GetSettingValue(AppSettings.WeChatMiniProgram.IsActive)))
            {
                configInfo.MiniProgramAppId     = settingManager.GetSettingValue(AppSettings.WeChatMiniProgram.AppId);
                configInfo.MiniProgramAppSecret = settingManager.GetSettingValue(AppSettings.WeChatMiniProgram.AppSecret);
            }
            MiniProgramSDKBuilder.Create()
            //设置日志记录
            .WithLoggerAction(LogAction).RegisterGetKeyFunc(() =>
            {
                var key = iocManager.Resolve <IAbpSession>()?.TenantId;
                if (key == null)
                {
                    return("0");
                }

                return(key.ToString());
            }).RegisterGetConfigByKeyFunc(key => configInfo).Build();
        }
Exemple #35
0
        public void RegisterForDbContext(Type dbContextType, IIocManager iocManager)
        {
            var autoRepositoryAttr = dbContextType.GetSingleAttributeOrNull <AutoRepositoryTypesAttribute>() ??
                                     EfCoreAutoRepositoryTypes.Default;

            foreach (var entityTypeInfo in DbContextHelper.GetEntityTypeInfos(dbContextType))
            {
                var primaryKeyType = EntityHelper.GetPrimaryKeyType(entityTypeInfo.EntityType);
                if (primaryKeyType == typeof(int))
                {
                    var genericRepositoryType = autoRepositoryAttr.RepositoryInterface.MakeGenericType(entityTypeInfo.EntityType);
                    if (!iocManager.IsRegistered(genericRepositoryType))
                    {
                        var implType = autoRepositoryAttr.RepositoryImplementation.GetGenericArguments().Length == 1
                                ? autoRepositoryAttr.RepositoryImplementation.MakeGenericType(entityTypeInfo.EntityType)
                                : autoRepositoryAttr.RepositoryImplementation.MakeGenericType(entityTypeInfo.DeclaringType, entityTypeInfo.EntityType);

                        iocManager.Register(
                            genericRepositoryType,
                            implType,
                            DependencyLifeStyle.Transient
                            );
                    }
                }

                var genericRepositoryTypeWithPrimaryKey = autoRepositoryAttr.RepositoryInterfaceWithPrimaryKey.MakeGenericType(entityTypeInfo.EntityType, primaryKeyType);
                if (!iocManager.IsRegistered(genericRepositoryTypeWithPrimaryKey))
                {
                    var implType = autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.GetGenericArguments().Length == 2
                                ? autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(entityTypeInfo.EntityType, primaryKeyType)
                                : autoRepositoryAttr.RepositoryImplementationWithPrimaryKey.MakeGenericType(entityTypeInfo.DeclaringType, entityTypeInfo.EntityType, primaryKeyType);

                    iocManager.Register(
                        genericRepositoryTypeWithPrimaryKey,
                        implType,
                        DependencyLifeStyle.Transient
                        );
                }
            }
        }
Exemple #36
0
        private MSBootStrapper([NotNull] Type startupModule, [CanBeNull] Action <MSBootstrapperOptions> optionsAction = null)
        {
            var options = new MSBootstrapperOptions();

            optionsAction?.Invoke(options);

            if (!typeof(MSModule).GetTypeInfo().IsAssignableFrom(startupModule))
            {
                throw new ArgumentException($"{nameof(startupModule)} should be derived from {nameof(MSModule)}.");
            }

            StartupModule = startupModule;

            IocManager = options.IocManager;

            _logger = NullLogger.Instance;

            if (!options.DisableAllInterceptors)
            {
                AddInterceptorRegistrars();
            }
        }
Exemple #37
0
        protected virtual void RegisterDependencies(XHConfig config)
        {
            var builder   = new ContainerBuilder();
            var container = builder.Build();

            this._containerManager = new ContainerManager(container);

            //we create new instance of ContainerBuilder
            //because Build() or Update() method can only be called once on a ContainerBuilder.

            //dependencies
            var typeFinder = new WebAppTypeFinder();

            builder = new ContainerBuilder();
            builder.RegisterInstance(config).As <XHConfig>().SingleInstance();
            builder.RegisterInstance(this).As <IEngine>().SingleInstance();
            builder.RegisterInstance(typeFinder).As <ITypeFinder>().SingleInstance();
            builder.Update(container);

            //register dependencies provided by other assemblies
            builder = new ContainerBuilder();
            var drTypes     = typeFinder.FindClassesOfType <IDependencyRegistrar>();
            var drInstances = new List <IDependencyRegistrar>();

            foreach (var drType in drTypes)
            {
                drInstances.Add((IDependencyRegistrar)Activator.CreateInstance(drType));
            }
            //sort
            drInstances = drInstances.AsQueryable().OrderBy(t => t.Order).ToList();
            foreach (var dependencyRegistrar in drInstances)
            {
                dependencyRegistrar.Register(builder, typeFinder, config);
            }
            builder.Update(container);

            //set dependency resolver
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
        }
        public static void Register(IIocManager iocManager)
        {
            var services = new ServiceCollection();

            WindsorRegistrationHelper.CreateServiceProvider(iocManager.IocContainer, services);

            var builder = new DbContextOptionsBuilder <TestDbContext>();

            var inMemorySqlite = new SqliteConnection("Data Source=:memory:");

            builder.UseSqlite(inMemorySqlite);

            iocManager.IocContainer.Register(
                Component
                .For <DbContextOptions <TestDbContext> >()
                .Instance(builder.Options)
                .LifestyleSingleton()
                );

            inMemorySqlite.Open();
            new TestDbContext(builder.Options).Database.EnsureCreated();
        }
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
            DevExpress.UserSkins.BonusSkins.Register();
            DevExpress.Utils.AppearanceObject.DefaultFont = new Font("Segoe UI", 8);
            DevExpress.LookAndFeel.UserLookAndFeel.Default.SetSkinStyle("Office 2019 Colorful");
            DevExpress.Skins.SkinManager.EnableMdiFormSkins();
            //加载IOC容器
            IIocManager iocManager = AbpApplicationBuilderExtensions.UseAbp <ZtgeoGISDesktopMoudle>(new SplashScreenFormManager(),
                                                                                                    optionAction =>
            {
                optionAction.IocManager.IocContainer.AddFacility <LoggingFacility>(
                    f => f.UseAbpLog4Net().WithConfig("log4net.config")
                    );
            });
            //初始化界面
            IMainForm mainForm = iocManager.Resolve <IMainForm>();

            if (mainForm != null)
            {
                #region 全局异常处理
                Application.ThreadException += (object sender, ThreadExceptionEventArgs e) =>
                {
                    EventBus.Default.Trigger <UIExceptionEventData>(new UIExceptionEventData {
                        ThreadExceptionEventArgs = e
                    });
                };
                AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler((object sender, UnhandledExceptionEventArgs e) =>
                {
                    EventBus.Default.Trigger <NonUIExceptionEventData>(new NonUIExceptionEventData {
                        UnhandledExceptionEventArgs = e
                    });
                });
                #endregion
                Application.Run((Form)mainForm);
            }
        }
Exemple #40
0
        private static void RegisterDbContextToSqliteInMemoryDb(IIocManager iocManager)
        {
            var builder = new DbContextOptionsBuilder <MyDbContext>();

            builder.ReplaceService <IEntityMaterializerSource, AbpEntityMaterializerSource>();

            var inMemorySqlite = new SqliteConnection("Data Source=:memory:");

            builder.UseSqlite(inMemorySqlite);

            iocManager.IocContainer.Register(
                Component
                .For <DbContextOptions <MyDbContext> >()
                .Instance(builder.Options)
                .LifestyleSingleton()
                );

            inMemorySqlite.Open();
            var ctx = new MyDbContext(builder.Options);

            ctx.Database.EnsureCreated();
        }
        public static void Register(IIocManager iocManager)
        {
            var services = new ServiceCollection();

            IdentityRegistrar.Register(services);

            services.AddEntityFrameworkInMemoryDatabase();

            var serviceProvider = WindsorRegistrationHelper.CreateServiceProvider(iocManager.IocContainer, services);

            var builder = new DbContextOptionsBuilder <MindfightsDbContext>();

            builder.UseInMemoryDatabase(Guid.NewGuid().ToString()).UseInternalServiceProvider(serviceProvider);

            iocManager.IocContainer.Register(
                Component
                .For <DbContextOptions <MindfightsDbContext> >()
                .Instance(builder.Options)
                .LifestyleSingleton()
                );

            iocManager.Register(typeof(IPlayerService), typeof(Player), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(ITeamService), typeof(Team), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(IMindfightService), typeof(Mindfight), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(IQuestionService), typeof(Question), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(ITeamAnswerService), typeof(TeamAnswer), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(IRegistrationService), typeof(Registration), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(IResultService), typeof(Result), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(ITourService), typeof(Tour), DependencyLifeStyle.Transient);

            iocManager.Register(typeof(IRepository <Models.City, long>), typeof(Models.City), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(IRepository <Models.Team, long>), typeof(Models.Team), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(IRepository <Models.Mindfight, long>), typeof(Models.Mindfight), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(IRepository <Models.Question, long>), typeof(Models.Question), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(IRepository <Models.TeamAnswer, long>), typeof(Models.TeamAnswer), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(IRepository <Models.Registration, long>), typeof(Models.Registration), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(IRepository <Models.MindfightResult, long>), typeof(Models.MindfightResult), DependencyLifeStyle.Transient);
            iocManager.Register(typeof(IRepository <Models.Tour, long>), typeof(Models.Tour), DependencyLifeStyle.Transient);
        }
Exemple #42
0
        public TestBaseWithLocalIocManager()
        {
            LocalIocManager = new IocManager();


            /*
             * 需要注意注册的次序!
             * 先注册拦截器
             */

            //开启uow事务
            UnitOfWorkRegistrar.Initialize(LocalIocManager);

            LocalIocManager.IocContainer.Register(
                Component.For(typeof(IDbContextProvider <>)).ImplementedBy(typeof(UnitOfWorkDbContextProvider <>)).LifestyleTransient(),
                Component.For <IUnitOfWorkDefaultOptions, UnitOfWorkDefaultOptions>().ImplementedBy <UnitOfWorkDefaultOptions>().LifestyleSingleton(),
                Component.For <IIocResolver, IocManager>().ImplementedBy <IocManager>().LifestyleSingleton(),
                Component.For <IUnitOfWorkManager>().ImplementedBy <UnitOfWorkManager>().LifestyleSingleton()
                );

            LocalIocManager.Register(typeof(UnitOfWorkInterceptor), DependencyLifeStyle.Singleton);

            //IocManager.Register<HelpController>(DependencyLifeStyle.Transient);

            LocalIocManager.IocContainer.Install(new FinderInstaller());
            LocalIocManager.AddConventionalRegistrar(new BasicConventionalRegistrar());

            LocalIocManager.RegisterAssemblyByConvention(typeof(IRepository).Assembly);
            LocalIocManager.RegisterAssemblyByConvention(typeof(DomainServiceBase).Assembly);
            LocalIocManager.RegisterAssemblyByConvention(typeof(AppServiceBase).Assembly);
            //LocalIocManager.RegisterAssemblyByConvention(typeof(TestBaseWithLocalIocManager).Assembly);

            //LocalIocManager.RegisterAssemblyByConvention(Assembly.Load("DDD.Domain.Common"));
            LocalIocManager.RegisterAssemblyByConvention(Assembly.Load("DDD.Domain.Core"));
            LocalIocManager.RegisterAssemblyByConvention(Assembly.Load("DDD.Domain.Service"));
            //IocManager.Register<IBlogRepository>();
            //IocManager.Register<IUserRepository>();
        }
Exemple #43
0
        /// <summary>
        /// Creates a new <see cref="Bootstrapper"/> instance.
        /// </summary>
        /// <param name="startupModule">Startup module of the application which depends on other used modules. Should be derived from <see cref="AbpModule"/>.</param>
        /// <param name="optionsAction">An action to set options</param>
        private Bootstrapper(Type startupModule, Action <BootstrapperOptions> optionsAction = null)
        {
            var options = new BootstrapperOptions();

            optionsAction?.Invoke(options);

            if (!typeof(BaseModule).GetTypeInfo().IsAssignableFrom(startupModule))
            {
                throw new ArgumentException($"{nameof(startupModule)} should be derived from {nameof(BaseModule)}.");
            }

            StartupModule = startupModule;

            IocManager    = options.IocManager;
            PlugInSources = options.PlugInSources;

            _logger = NullLogger.Instance;

            if (!options.DisableAllInterceptors)
            {
                AddInterceptorRegistrars();
            }
        }
        static TResult Forward <TResult>(ControllerContext controllerContext, IIocManager iIocManager,
                                         Func <IThemeAwareViewEngine, TResult> forwardAction, Func <TResult> defaultAction)
        {
//            var workContext = controllerContext.GetWorkContext();
//            if (workContext != null)
//            {
//                var displayViewEngine = workContext.Resolve<IThemeAwareViewEngine>();
//                if (displayViewEngine != null)
//                {
//                    return forwardAction(displayViewEngine);
//                }
//            }

            if (iIocManager != null)
            {
                var displayViewEngine = iIocManager.Resolve <IThemeAwareViewEngine>();
                if (displayViewEngine != null)
                {
                    return(forwardAction(displayViewEngine));
                }
            }
            return(defaultAction());
        }
Exemple #45
0
        public void RegisterForDbContext(Type dbContextType, IIocManager iocManager)
        {
            var RepositoryInterface      = typeof(IExtendedRepository <>);
            var RepositoryImplementation = typeof(EfRepositoryBase <,>);


            foreach (EntityTypeInfo entityTypeInfo in ExtendedDbContextHelper.GetDbEntityTypeInfos(dbContextType))
            {
                Type genericRepositoryType = RepositoryInterface.MakeGenericType(new Type[] { entityTypeInfo.EntityType });
                if (!iocManager.IsRegistered(genericRepositoryType))
                {
                    Type implType = (RepositoryImplementation.GetGenericArguments().Length == 1) ? RepositoryImplementation.MakeGenericType(new Type[]
                    {
                        entityTypeInfo.EntityType
                    }) : RepositoryImplementation.MakeGenericType(new Type[]
                    {
                        entityTypeInfo.DeclaringType,
                        entityTypeInfo.EntityType
                    });
                    iocManager.Register(genericRepositoryType, implType, DependencyLifeStyle.Transient);
                }
            }
        }
        private void RegisterForDbContext(
            Type dbContextType,
            IIocManager iocManager,
            Type repositoryInterface,
            Type repositoryInterfaceWithPrimaryKey,
            Type repositoryImplementation,
            Type repositoryImplementationWithPrimaryKey)
        {
            foreach (var entityTypeInfo in _dbContextEntityFinder.GetEntityTypeInfos(dbContextType))
            {
                var primaryKeyType = EntityHelper.GetPrimaryKeyType(entityTypeInfo.EntityType);
                if (primaryKeyType == typeof(int))
                {
                    var genericRepositoryType = repositoryInterface.MakeGenericType(entityTypeInfo.EntityType);
                    if (!iocManager.IsRegistered(genericRepositoryType))
                    {
                        var implType = repositoryImplementation.GetGenericArguments().Length == 1
                            ? repositoryImplementation.MakeGenericType(entityTypeInfo.EntityType)
                            : repositoryImplementation.MakeGenericType(entityTypeInfo.DeclaringType,
                                                                       entityTypeInfo.EntityType);

                        iocManager.IocContainer.Register(genericRepositoryType, implType, Reuse.Transient);
                    }
                }

                var genericRepositoryTypeWithPrimaryKey = repositoryInterfaceWithPrimaryKey.MakeGenericType(entityTypeInfo.EntityType, primaryKeyType);
                if (!iocManager.IsRegistered(genericRepositoryTypeWithPrimaryKey))
                {
                    var implType = repositoryImplementationWithPrimaryKey.GetGenericArguments().Length == 2
                        ? repositoryImplementationWithPrimaryKey.MakeGenericType(entityTypeInfo.EntityType, primaryKeyType)
                        : repositoryImplementationWithPrimaryKey.MakeGenericType(entityTypeInfo.DeclaringType, entityTypeInfo.EntityType, primaryKeyType);

                    iocManager.IocContainer.Register(genericRepositoryTypeWithPrimaryKey, implType, Reuse.Transient);
                }
            }
        }
        /// <summary>
        /// Creates a new <see cref="AbpBootstrapper"/> instance.
        /// </summary>
        /// <param name="startupModule">Startup module of the application which depends on other used modules. Should be derived from <see cref="AbpModule"/>.</param>
        /// <param name="optionsAction">An action to set options</param>
        private AbpBootstrapper(
            [NotNull] Type startupModule,
            [CanBeNull] Action <AbpBootstrapperOptions> optionsAction = null)
        {
            Check.NotNull(startupModule, nameof(startupModule));

            var options = new AbpBootstrapperOptions();

            optionsAction?.Invoke(options);

            if (!typeof(AbpModule).GetTypeInfo().IsAssignableFrom(startupModule))
            {
                throw new ArgumentException($"{nameof(startupModule)} should be derived from {nameof(AbpModule)}.");
            }

            StartupModule = startupModule;

            IocManager    = options.IocManager;
            PlugInSources = options.PlugInSources;

            _logger = NullLogger.Instance;

            AddInterceptorRegistrars(options.InterceptorOptions);
        }
        public OracleTestBaseWithLocalIocManager()
        {
            LocalIocManager = new IocManager();


            /*
             * 需要注意注册的次序!
             * 先注册拦截器
             */

            //开启uow事务
            UnitOfWorkRegistrar.Initialize(LocalIocManager);

            LocalIocManager.IocContainer.Register(
                Component.For(typeof(IDbContextProvider <>)).ImplementedBy(typeof(UnitOfWorkDbContextProvider <>)).LifestyleTransient(),
                Component.For <IUnitOfWorkDefaultOptions, UnitOfWorkDefaultOptions>().ImplementedBy <UnitOfWorkDefaultOptions>().LifestyleSingleton(),
                Component.For <IIocResolver, IocManager>().ImplementedBy <IocManager>().LifestyleSingleton(),
                Component.For <IUnitOfWorkManager>().ImplementedBy <UnitOfWorkManager>().LifestyleSingleton()
                //Component.For<IAutoMapperInitializer, AutoMapperInitializer>().ImplementedBy<AutoMapperInitializer>().LifestyleSingleton()
                );


            LocalIocManager.Register(typeof(UnitOfWorkInterceptor), DependencyLifeStyle.Singleton);


            //IocManager.Register<HelpController>(DependencyLifeStyle.Transient);

            LocalIocManager.IocContainer.Install(new FinderInstaller());
            LocalIocManager.AddConventionalRegistrar(new BasicConventionalRegistrar());

            LocalIocManager.RegisterAssemblyByConvention(typeof(IAutoMapperModule).Assembly);
            LocalIocManager.RegisterAssemblyByConvention(typeof(IInfrastructureDomainModule).Assembly);
            LocalIocManager.RegisterAssemblyByConvention(typeof(IDomainCoreModule).Assembly);
            LocalIocManager.RegisterAssemblyByConvention(typeof(IDomainServiceModule).Assembly);
            LocalIocManager.RegisterAssemblyByConvention(typeof(IAppServiceModule).Assembly);
        }
        public void Register(IIocManager iocManager)
        {
            var services = new ServiceCollection();

            IdentityRegistrar.Register(services);

            services.AddEntityFrameworkSqlite();

            var serviceProvider = WindsorRegistrationHelper.CreateServiceProvider(iocManager.IocContainer, services);

            // In-memory database only exists while the connection is open
            _connection = new SqliteConnection("DataSource=:memory:");
            _connection.Open();

            var builder = new DbContextOptionsBuilder <AcmStatisticsBackendDbContext>();

            builder.UseSqlite(_connection).UseInternalServiceProvider(serviceProvider);

            iocManager.IocContainer.Register(
                Component
                .For <DbContextOptions <AcmStatisticsBackendDbContext> >()
                .Instance(builder.Options)
                .LifestyleSingleton());
        }
        private WindBootstrapper(Type startupModule, IIocManager iocManager)
        {
            if (startupModule == null)
            {
                throw new ArgumentNullException("startupModule");
            }
            if (iocManager == null)
            {
                throw new ArgumentNullException("iocManager");
            }

            if (!typeof(WindModule).IsAssignableFrom(startupModule))
            {
                throw new ArgumentException(startupModule + " should be derived from WindModule.");
            }

            StartupModule = startupModule;
            IocManager    = iocManager;

            PlugInSources = new PlugInSourceList();
            _logger       = NullLogger.Instance;

            AddInterceptorRegistrars();
        }
Exemple #51
0
 /// <summary>
 ///     Constructor.
 /// </summary>
 public SettingDefinitionManager(IIocManager iocManager, ISettingsConfiguration settingsConfiguration)
 {
     this.iocManager            = iocManager;
     this.settingsConfiguration = settingsConfiguration;
     settings = new Dictionary <string, SettingDefinition>();
 }
Exemple #52
0
 /// <summary>
 ///     创建系统启动器
 /// </summary>
 /// <typeparam name="TStartupModule">模块</typeparam>
 /// <param name="iocManager">容器管理器</param>
 public static DcpBootstrapper Create <TStartupModule>(IIocManager iocManager) where TStartupModule : DcpModule => new DcpBootstrapper(typeof(TStartupModule), iocManager);
Exemple #53
0
 /// <summary>
 ///     创建启动器
 /// </summary>
 /// <param name="startupModule"></param>
 /// <param name="iocManager"></param>
 public static DcpBootstrapper Create(Type startupModule, IIocManager iocManager) => new DcpBootstrapper(startupModule, iocManager);
 public CncCoreWorker(IIocManager _iocManager)
 {
     iocManager = _iocManager;
 }
 public NavigationTestCase(IIocManager iocManager)
 {
     _iocManager = iocManager;
     Initialize();
 }
Exemple #56
0
 /// <summary>
 /// Constructor.
 /// </summary>
 public AbpMemoryCacheManager(IIocManager iocManager, ICachingConfiguration configuration)
     : base(iocManager, configuration)
 {
     IocManager.RegisterIfNot <AbpMemoryCache>(DependencyLifeStyle.Transient);
 }
 public ExternalLoginInfoManagerFactory(IIocManager iocManager)
 {
     _iocManager = iocManager;
 }
Exemple #58
0
 public static void RegisterAssembly(IIocManager iocManager)
 {
     iocManager.RegisterAssemblyByConvention(typeof(QksPluginDbContext).GetAssembly());
 }
Exemple #59
0
 /// <summary>
 /// Initializes a new instance of the <see cref="MultiTenantLocalizationDictionaryProvider"/> class.
 /// </summary>
 public MultiTenantLocalizationDictionaryProvider(ILocalizationDictionaryProvider internalProvider, IIocManager iocManager)
 {
     _internalProvider = internalProvider;
     _iocManager       = iocManager;
     _dictionaries     = new ConcurrentDictionary <string, ILocalizationDictionary>();
 }
Exemple #60
0
 public static void Initialize(IIocManager iocManager)
 {
     iocManager.IocContainer.Kernel.ComponentRegistered += Kernel_ComponentRegistered;
 }