Example #1
0
        public void Register(Autofac.ContainerBuilder builder, ITypeFinder typeFinder)
        {
            builder.RegisterType<WorkflowEngine>().As<IWorkflowEngine>().InstancePerHttpRequest();
            builder.RegisterAssemblyTypes(typeFinder.GetAssemblies().ToArray())
               .AssignableTo<IAutoActivityHandler>()
               .AsImplementedInterfaces();

            Assembly[] assemblies = typeFinder.GetAssemblies().ToArray();
            builder.RegisterAssemblyTypes(assemblies)
               .AssignableTo<IAutoActivityHandler>()
               .AsImplementedInterfaces();

            //regisger  [UUID("ApplyQuota-2.0-Approve-ActivityExecutedEvent")]
            var handlers = typeFinder.FindClassesOfType(typeof(IAutoActivityHandler)).ToList();
            foreach (var handler in handlers)
            {
                object[] attrs = handler.GetCustomAttributes(typeof(UUIDAttribute), false);
                string uuid = string.Empty;
                if (attrs != null)
                {
                    foreach (UUIDAttribute attr in attrs)
                    {
                        uuid = attr.UUID;
                    }
                    builder.RegisterType(handler).As<IAutoActivityHandler>().Keyed<IAutoActivityHandler>(uuid)
                    .InstancePerHttpRequest();
                }
            }

            //regisger  [UUID("ApplyQuota-2.0-Approve-ActivityExecutedEvent")]
            var consumers = typeFinder.FindClassesOfType(typeof(IConsumer<>)).ToList();
            foreach (var consumer in consumers)
            {
                object[] attrs = consumer.GetCustomAttributes(typeof(UUIDAttribute), false);
                string uuid = string.Empty;
                if (attrs != null)
                {
                    foreach (UUIDAttribute attr in attrs)
                    {
                        uuid = attr.UUID;
                    }
                    var interfaceType = consumer.FindInterfaces((type, criteria) =>
                    {
                        var isMatch = type.IsGenericType && ((Type)criteria).IsAssignableFrom(type.GetGenericTypeDefinition());
                        return isMatch;
                    }, typeof(IConsumer<>))[0];
                    builder.RegisterType(consumer).As(interfaceType)
                    .Keyed(uuid, interfaceType)
                    .InstancePerHttpRequest();
                }
            }
        }
        public void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            //HttpContext
            builder.Register(c =>
                //register FakeHttpContext when HttpContext is not available
                HttpContext.Current != null
                    ? (new HttpContextWrapper(HttpContext.Current) as HttpContextBase)
                    : (new FakeHttpContext("~/") as HttpContextBase))
                .As<HttpContextBase>()
                .InstancePerLifetimeScope();
            builder.Register(c => c.Resolve<HttpContextBase>().Request)
                .As<HttpRequestBase>()
                .InstancePerLifetimeScope();
            builder.Register(c => c.Resolve<HttpContextBase>().Response)
                .As<HttpResponseBase>()
                .InstancePerLifetimeScope();
            builder.Register(c => c.Resolve<HttpContextBase>().Server)
                .As<HttpServerUtilityBase>()
                .InstancePerLifetimeScope();
            builder.Register(c => c.Resolve<HttpContextBase>().Session)
                .As<HttpSessionStateBase>()
                .InstancePerLifetimeScope();


            builder.RegisterType<PageHeadBuilder>().As<IPageHeadBuilder>().InstancePerLifetimeScope();

            //MVC
            builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());

            //Api
            builder.RegisterApiControllers(typeFinder.GetAssemblies().ToArray());

            //Route
            builder.RegisterType<RoutePublisher>().As<IRoutePublisher>().SingleInstance();

            builder.RegisterType<WebWorkContext>().As<IWorkContext>().InstancePerLifetimeScope();

            //Cache
            builder.RegisterType<MemoryCacheManager>().As<ICacheManager>().SingleInstance();
            //WebHelper
            builder.RegisterType<WebHelper>().As<IWebHelper>().InstancePerDependency();
            //Services
            builder.RegisterType<LocalizationService>().As<ILocalizationService>()
                .InstancePerLifetimeScope();
            builder.RegisterType<FormsAuthenticationService>().As<IAuthenticationService>().InstancePerLifetimeScope();
            builder.RegisterType<UserService>().As<IUserService>().InstancePerLifetimeScope();
            builder.RegisterType<InstallationService>().As<IInstallationService>().InstancePerLifetimeScope();
        }
        public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            //webworkcontenxt 上下文注入
               builder.RegisterType<WebWorkContext>().As<IWorkContext>().InstancePerLifetimeScope();
               //bll 注入
               builder.RegisterType<CustomerService>().As<ICustomersService>().InstancePerLifetimeScope();
               //用户身份认证
               builder.RegisterType<AuthenticationService>().As<IAuthenticationService>().InstancePerHttpRequest();
               //验证码管理器
               builder.RegisterType<DefaultCaptchaManager>().As<ICaptchaManager>().SingleInstance();
               //缓存注册
               //builder.Register(c => new DefaultCacheService(new RuntimeMemoryCache(), 1.0f))
               //    .As<ICacheService>()
               //    .SingleInstance();
               //cachemanager注入

               //系统日志注入
               builder.RegisterType<Log4NetLoggerFactoryAdapter>().As<ILoggerFactoryAdapter>().SingleInstance();
               builder.RegisterType<CacheManagerFactoryAdapter>().As<ICacheManagerFactoryAdapter>().SingleInstance();
               //所有的controllers 注入
               builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());

               //数据层注入

               var configstrategy = new ConfigStrategy();
               var RDBSConfigInfo = configstrategy.GetRDBSConfigInfo();
               builder.Register<IDbContext>(
               c => new ShepherdsFrameworkDbContext(RDBSConfigInfo.RDBSConnectionString))
               .InstancePerLifetimeScope();
               //泛型注入
               builder.RegisterGeneric(typeof(EFRepository<>)).As(typeof(IRepository<>)).InstancePerLifetimeScope();
        }
        public void Register(ContainerBuilder builder, ITypeFinder typeFinder, NopConfig config)
        {



            builder.RegisterType<MovieService>().As<IMovieService>().InstancePerLifetimeScope();


            builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());

            string conn = "Data Source=.;Initial Catalog=Axxe;Trusted_Connection=False;";

            builder.RegisterGeneric(typeof(EfRepository<>)).As(typeof(IRepository<>)).InstancePerLifetimeScope();

            var dataSettingsManager = new DataSettingsManager();
            var dataProviderSettings = dataSettingsManager.LoadSettings();
            builder.Register(c => dataSettingsManager.LoadSettings()).As<DataSettings>();
            builder.Register<IDbContext>(c => new NopObjectContext(conn)).InstancePerLifetimeScope();

            builder.Register(x => new EfDataProviderManager(x.Resolve<DataSettings>())).As<BaseDataProviderManager>().InstancePerDependency();
            var efDataProviderManager = new EfDataProviderManager(dataSettingsManager.LoadSettings());
            var dataProvider = efDataProviderManager.LoadDataProvider();
            dataProvider.InitConnectionFactory();

        }
        public void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());

            builder.Register<IDbContext>(c => new MmDataContext(ConfigurationManager.ConnectionStrings["MmDataContext"].ConnectionString)).InstancePerHttpRequest();

            builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>)).InstancePerHttpRequest();

            builder.Register(c => new HttpContextWrapper(HttpContext.Current) as HttpContextBase)
                .As<HttpContextBase>()
                .InstancePerHttpRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Request)
                .As<HttpRequestBase>()
                .InstancePerHttpRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Response)
                .As<HttpResponseBase>()
                .InstancePerHttpRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Server)
                .As<HttpServerUtilityBase>()
                .InstancePerHttpRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Session)
                .As<HttpSessionStateBase>()
                .InstancePerHttpRequest();

            //services
            builder.RegisterType<FormAuthenticationService>().As<IAuthenticationService>().InstancePerHttpRequest();
            builder.RegisterType<UserService>().As<IUserService>().InstancePerHttpRequest();
            builder.RegisterType<EmailSender>().As<IEmailSender>().InstancePerHttpRequest();
            builder.RegisterType<ArticleService>().As<IArticleService>().InstancePerHttpRequest();
            builder.RegisterType<FormatService>().As<IFormatService>().InstancePerHttpRequest();
            builder.RegisterType<MaterialService>().As<IMaterialService>().InstancePerHttpRequest();
            builder.RegisterType<TagService>().As<ITagService>().InstancePerHttpRequest();
            builder.RegisterType<ThingService>().As<IThingService>().InstancePerHttpRequest();
            builder.RegisterType<StateService>().As<IStateService>().InstancePerHttpRequest();
        }
Example #6
0
        public void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            builder.RegisterApiControllers(typeFinder.GetAssemblies().ToArray());
            builder.RegisterType<R2DisasterContext>().As<IDbContext>().InstancePerRequest();
            builder.RegisterGeneric(typeof(EFRepository<>)).As(typeof(IRepository<>)).InstancePerRequest();
            builder.RegisterType<BookRepository>().As<IBookRepository>().InstancePerRequest();

            builder.RegisterType<BookService>().As<IBookService>().InstancePerRequest();
            builder.RegisterType<ComprehensiveService>().As<IComprehensiveService>().InstancePerRequest();
            builder.RegisterType<DebrisFlowService>().As<IDebrisFlowService>().InstancePerRequest();
            builder.RegisterType<PhyGeoDisasterService>().As<IPhyGeoDisasterService>().InstancePerRequest();
         //   builder.RegisterType<Phy>().As<IPhyGeoDisasterService>().InstancePerRequest();
            builder.RegisterType<MassPreService>().As<IMassPreService>().InstancePerRequest();
            builder.RegisterType<MonthlyReportService>().As<IMonthlyReportService>().InstancePerRequest();
            builder.RegisterType<EmergencySurveyReportService>().As<IEmergencySurveyReportService>().InstancePerRequest();
            //矿山复绿
            builder.RegisterType<MineArchiveService>().As<IMineArchiveService>().InstancePerRequest();
            builder.RegisterType<MineEnvironmentSurveyService>().As<IMineEnvironmentSurveyService>().InstancePerRequest();
            builder.RegisterType<MineRemoteSensingCardService>().As<IMineRemoteSensingCardService>().InstancePerRequest();
            //移民搬迁
            builder.RegisterType<RelocationComprehensiveService>().As<IRelocationComprehensiveService>().InstancePerRequest();
            builder.RegisterType<RelocationDebrisFlowCheckService>().As<IRelocationDebrisFlowCheckService>().InstancePerRequest();
            builder.RegisterType<RelocationLandCollapseCheckService>().As<IRelocationLandCollapseCheckService>().InstancePerRequest();
            builder.RegisterType<RelocationLandSlideCheckService>().As<IRelocationLandSlideCheckService>().InstancePerRequest();
            builder.RegisterType<RelocationLandSlipCheckService>().As<IRelocationLandSlipCheckService>().InstancePerRequest();
            builder.RegisterType<RelocationSlopeCheckService>().As<IRelocationSlopeCheckService>().InstancePerRequest();
            builder.RegisterType<RelocationPlaceEvaluationService>().As<IRelocationPlaceEvaluationService>().InstancePerRequest();

            builder.RegisterType<RainfallStationService>().As<IRainfallStationService>().InstancePerRequest();
        }
        public void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            //controllers
            builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());
            //data access
            var dataSettingsManager = new DataSettingsManager();
            var dataProviderSettings = dataSettingsManager.LoadSettings();
            //todo:暂时把连接字符串写死,测试时使用
            //dataProviderSettings.DataConnectionString = @"Data Source=(localdb)\ProjectsV12;Initial Catalog=FzrainFramework;attachdbfilename=E:\MyFramework\Fzrain.Framework\Fzrain.Web\App_Data\FzrainFramework.mdf;Integrated Security=True;Persist Security Info=False;";
            //dataProviderSettings.DataProvider = "sqlserver";
            builder.Register(c => dataProviderSettings).As<DataSettings>();
            builder.Register(x => new EfDataProviderManager(x.Resolve<DataSettings>())).As<BaseDataProviderManager>().InstancePerDependency();

            builder.Register(x => x.Resolve<BaseDataProviderManager>().LoadDataProvider()).As<IDataProvider>().InstancePerDependency();

            if (dataProviderSettings != null && dataProviderSettings.IsValid())
            {
                var efDataProviderManager = new EfDataProviderManager(dataProviderSettings);
                var dataProvider = efDataProviderManager.LoadDataProvider();
                dataProvider.InitConnectionFactory();

                builder.Register<IDbContext>(c => new FzrainContext(dataProviderSettings.DataConnectionString)).InstancePerLifetimeScope();
            }
            else
            {
                builder.Register<IDbContext>(c => new FzrainContext(dataSettingsManager.LoadSettings().DataConnectionString)).InstancePerLifetimeScope();
            }
            //repository
            builder.RegisterGeneric(typeof(EfRepository<>)).As(typeof(IRepository<>)).InstancePerLifetimeScope();

            //service
            builder.RegisterType<UserService>().As<IUserService>().InstancePerLifetimeScope();
            builder.RegisterType<LolService>().As<ILolService>().InstancePerLifetimeScope();
            builder.RegisterType<SettingService>().As<ISettingService>().InstancePerLifetimeScope();
        }
        public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            builder.RegisterType<WebWorkContext>().As<IWorkContext>().InstancePerLifetimeScope();
               builder.RegisterType<CustomerService>().As<ICustomersService>().InstancePerLifetimeScope();

               //所有的controllers 注入
               builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());
        }
Example #9
0
        public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());
            builder.RegisterType<R2HaloContext>().As<IDbContext>().InstancePerRequest();
            builder.RegisterGeneric(typeof(EFRepository<>)).As(typeof(IRepository<>)).InstancePerRequest();
            builder.RegisterType<DefaultLogger>().As<ILogger>().InstancePerHttpRequest();
            builder.RegisterAssemblyTypes(Assembly.GetAssembly(typeof(EntityServiceBase<>))).Where(t => t.Name.EndsWith("Service")).AsImplementedInterfaces().InstancePerRequest();       
            //以上为黄圣所加 
            builder.RegisterType<EmbeddedViewResolver>().As<IEmbeddedViewResolver>().SingleInstance();
            builder.RegisterType<RoutePublisher>().As<IRoutePublisher>().SingleInstance();

        }
        public void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            builder.RegisterApiControllers(typeFinder.GetAssemblies().ToArray());
            builder.RegisterType<R2DisasterContext>().As<IDbContext>().InstancePerRequest();
            builder.RegisterGeneric(typeof(EFRepository<>)).As(typeof(IRepository<>)).InstancePerRequest();
            builder.RegisterType<BookRepository>().As<IBookRepository>().InstancePerRequest();

            builder.RegisterType<BookService>().As<IBookService>().InstancePerRequest();
            builder.RegisterType<ComprehensiveService>().As<IComprehensiveService>().InstancePerRequest();
            builder.RegisterType<DebrisFlowService>().As<IDebrisFlowService>().InstancePerRequest();
            builder.RegisterType<PhyGeoDisasterService>().As<IPhyGeoDisasterService>().InstancePerRequest();
            builder.RegisterType<MassPreService>().As<IMassPreService>().InstancePerRequest();
            builder.RegisterType<RainfallStationService>().As<IRainfallStationService>().InstancePerRequest();
        }
Example #11
0
        public void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            builder.Register(c => new HttpContextWrapper(HttpContext.Current) as HttpContextBase)
                .As<HttpContextBase>()
                .InstancePerHttpRequest();

            builder.Register<IDbContext>(c=>new PublicDataContext()).InstancePerHttpRequest();
            builder.RegisterGeneric(typeof(EfRepository<>)).As(typeof(IRepository<>)).InstancePerHttpRequest();
            builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());

            builder.RegisterType<MemoryCacheManager>().As<ICacheManager>().SingleInstance();
            builder.RegisterType<PerRequestCacheManager>().As<ICacheManager>().Named<ICacheManager>("nop_cache_per_request").InstancePerHttpRequest();
            builder.RegisterType<WebHelper>().As<IWebHelper>().InstancePerHttpRequest();
        }
        public static void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            //webworkcontenxt 上下文注入
               builder.RegisterType<WebWorkContext>().As<IWorkContext>().InstancePerLifetimeScope();
               //bll 注入
               builder.RegisterType<CustomerService>().As<ICustomersService>().InstancePerLifetimeScope();

               //所有的controllers 注入
               builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());

               //数据层注入
               //泛型注入
               builder.RegisterGeneric(typeof(EFRepository<>)).As(typeof(IRepository<>)).InstancePerLifetimeScope();
        }
        public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            //webworkcontenxt 上下文注入
               builder.RegisterType<WebWorkContext>().As<IWorkContext>().InstancePerLifetimeScope();
               //bll 注入
               builder.RegisterType<CustomerService>().As<ICustomersService>().InstancePerLifetimeScope();

               //所有的controllers 注入
               builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());

               //数据层注入

               var configstrategy = new ConfigStrategy();
               builder.Register<IDbContext>(c => new ShepherdsFrameworkDbContext(configstrategy.GetRDBSConfigInfo().RDBSConnectionString))
               //泛型注入
               builder.RegisterGeneric(typeof(EFRepository<>)).As(typeof(IRepository<>)).InstancePerLifetimeScope();
        }
        /// <summary>
        /// The register.
        /// </summary>
        /// <param name="builder">
        /// The builder.
        /// </param>
        /// <param name="typeFinder">
        /// The type finder.
        /// </param>
        /// <param name="isActiveModule">
        /// The is active module.
        /// </param>
        public void Register(ContainerBuilder builder, ITypeFinder typeFinder, bool isActiveModule)
        {
            // HTTP context and other related stuff
               builder.Register(
               c => // register FakeHttpContext when HttpContext is not available
               (new HttpContextWrapper(HttpContext.Current) as HttpContextBase))
               .As<HttpContextBase>()
               .InstancePerLifetimeScope();
               builder.Register(c => c.Resolve<HttpContextBase>().Request).As<HttpRequestBase>().InstancePerLifetimeScope();
               builder.Register(c => c.Resolve<HttpContextBase>().Response)
               .As<HttpResponseBase>()
               .InstancePerLifetimeScope();
               builder.Register(c => c.Resolve<HttpContextBase>().Server)
               .As<HttpServerUtilityBase>()
               .InstancePerLifetimeScope();
               builder.Register(c => c.Resolve<HttpContextBase>().Session)
               .As<HttpSessionStateBase>()
               .InstancePerLifetimeScope();

               // controllers
               var controllers = typeFinder.GetAssemblies().ToArray();
               builder.RegisterControllers(controllers);
        }
Example #15
0
        public void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            //HTTP context and other related stuff
            builder.Register(c =>
                //register FakeHttpContext when HttpContext is not available
                HttpContext.Current != null ?
                (new HttpContextWrapper(HttpContext.Current) as HttpContextBase) :
                (new FakeHttpContext("~/") as HttpContextBase))
                .As<HttpContextBase>()
                .InstancePerLifetimeScope();
            builder.Register(c => c.Resolve<HttpContextBase>().Request)
                .As<HttpRequestBase>()
                .InstancePerLifetimeScope();
            builder.Register(c => c.Resolve<HttpContextBase>().Response)
                .As<HttpResponseBase>()
                .InstancePerLifetimeScope();
            builder.Register(c => c.Resolve<HttpContextBase>().Server)
                .As<HttpServerUtilityBase>()
                .InstancePerLifetimeScope();
            builder.Register(c => c.Resolve<HttpContextBase>().Session)
                .As<HttpSessionStateBase>()
                .InstancePerLifetimeScope();


            //controllers
            builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());


            builder.Register<IDbContext>(c => new BlogObjectContext()).InstancePerLifetimeScope();
            builder.RegisterGeneric(typeof(EfRepository<>)).As(typeof(IRepository<>)).InstancePerLifetimeScope();

            builder.RegisterType<BlogService>().As<IBlogService>().InstancePerLifetimeScope();
            builder.RegisterType<UrlService>().As<IUrlService>().InstancePerLifetimeScope();

            builder.RegisterType<RoutePublisher>().As<IRoutePublisher>().SingleInstance();

        }
        public void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            builder.Register(c =>
                //register FakeHttpContext when HttpContext is not available
                HttpContext.Current != null ?
                (new HttpContextWrapper(HttpContext.Current) as HttpContextBase) :
                (new FakeHttpContext("~/") as HttpContextBase))
                .As<HttpContextBase>()
                .InstancePerLifetimeScope();

            var dataSettingsManager = new DataSettingsManager();
            var dataProviderSettings = dataSettingsManager.LoadSettings();

            if (dataProviderSettings != null && dataProviderSettings.IsValid())
            {
                builder.Register<IDbContext>(c => new BlueskyObjectContext(dataProviderSettings.DataConnectionString)).InstancePerLifetimeScope();
            }
            else
            {
                builder.Register<IDbContext>(c => new BlueskyObjectContext(dataSettingsManager.LoadSettings().DataConnectionString)).InstancePerLifetimeScope();
            }
            builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());
            builder.RegisterGeneric(typeof(EfRepository<>)).As(typeof(IRepository<>)).InstancePerLifetimeScope();
            builder.RegisterType<WebHelper>().As<IWebHelper>().InstancePerLifetimeScope();

            builder.RegisterType<FormsAuthenticationService>().As<IAuthenticationService>().InstancePerLifetimeScope();
            builder.RegisterType<WebWorkContext>().As<IWorkContext>().InstancePerLifetimeScope();
            builder.RegisterType<AccountService>().As<IAccountService>().InstancePerLifetimeScope();

            builder.RegisterType<BankService>().As<IBankService>().InstancePerLifetimeScope();
            builder.RegisterType<AccountRoleService>().As<IAccountRoleService>().InstancePerLifetimeScope();
            builder.RegisterType<ActivityLogService>().As<IActivityLogService>().InstancePerLifetimeScope();

            builder.RegisterType<AccountRegistrationService>().As<IAccountRegistrationService>().InstancePerLifetimeScope();
            builder.RegisterType<EncryptionService>().As<IEncryptionService>().InstancePerLifetimeScope();
        }
        public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            //HTTP context and other related stuff
            builder.Register(c =>
                             //register FakeHttpContext when HttpContext is not available
                             //HttpContext.Current != null ?
                             (new HttpContextWrapper(HttpContext.Current) as HttpContextBase)
                             //(new FakeHttpContext("~/") as HttpContextBase)
                             )
            .As <HttpContextBase>()
            .InstancePerRequest();
            builder.Register(c => c.Resolve <HttpContextBase>().Request)
            .As <HttpRequestBase>()
            .InstancePerRequest();
            builder.Register(c => c.Resolve <HttpContextBase>().Response)
            .As <HttpResponseBase>()
            .InstancePerRequest();
            builder.Register(c => c.Resolve <HttpContextBase>().Server)
            .As <HttpServerUtilityBase>()
            .InstancePerRequest();
            builder.Register(c => c.Resolve <HttpContextBase>().Session)
            .As <HttpSessionStateBase>()
            .InstancePerRequest();

            //web helper
            //builder.RegisterType<WebHelper>().As<IWebHelper>().InstancePerRequest();

            var assemblies = typeFinder.GetAssemblies().ToArray();

            //controllers
            builder.RegisterControllers(assemblies);
            //ApiControllers
            builder.RegisterApiControllers(assemblies);

            //View
            //builder.RegisterSource(new ViewRegistrationSource());

            //data layer
            var dataSettingsManager  = new DataSettingsManager();
            var dataProviderSettings = dataSettingsManager.LoadSettings();

            builder.Register(c => dataSettingsManager.LoadSettings()).As <DataSettings>();
            builder.Register(x => new EfDataProviderManager(x.Resolve <DataSettings>())).As <BaseDataProviderManager>().InstancePerDependency();


            builder.Register(x => x.Resolve <BaseDataProviderManager>().LoadDataProvider()).As <IDataProvider>().InstancePerDependency();

            if (dataProviderSettings != null && dataProviderSettings.IsValid())
            {
                var efDataProviderManager = new EfDataProviderManager(dataSettingsManager.LoadSettings());
                var dataProvider          = efDataProviderManager.LoadDataProvider();
                //dataProvider.InitConnectionFactory();
                ((SqlServerDataProvider)dataProvider).InitDatabase();

                builder.Register <IDbContext>(c => new EfDbContext(dataProviderSettings.DataConnectionString)).InstancePerRequest();
            }
            else
            {
                builder.Register <IDbContext>(c => new EfDbContext(dataSettingsManager.LoadSettings().DataConnectionString)).InstancePerRequest();
            }


            builder.RegisterGeneric(typeof(EfRepository <>)).As(typeof(IRepository <>)).InstancePerRequest();

            builder.RegisterAssemblyTypes(assemblies)
            .Where(t => typeof(IDependency).IsAssignableFrom(t) && t != typeof(IDependency))
            .AsImplementedInterfaces()
            .InstancePerRequest();
            builder.RegisterAssemblyTypes(assemblies)
            .Where(t => typeof(ISingletonDependency).IsAssignableFrom(t) && t != typeof(ISingletonDependency))
            .AsImplementedInterfaces()
            .SingleInstance();

            //IWorkContext
            builder.RegisterType <WorkContext>().As <IWorkContext>().InstancePerRequest();

            //filter
            builder.RegisterFilterProvider(); //todo:使用YpDependencyResolver时此方法会报空,用官方自带的不会
            builder.RegisterWebApiFilterProvider(GlobalConfiguration.Configuration);

            //注册YpHnadleError
            //全局注册
            builder.RegisterType <YpHandleErrorAttribute>().AsExceptionFilterFor <Controller>().SingleInstance();
            builder.RegisterType <YpAPIHandleErrorAttribute>().AsWebApiExceptionFilterFor <ApiController>().SingleInstance();
            //单个注册
            //builder.RegisterType<YpHandleErrorAttribute>().SingleInstance();
            //builder.RegisterType<YpAPIHandleErrorAttribute>().SingleInstance();

            //注册YpAuthorizeAttribute
            //全局注册
            builder.RegisterType <YpAPIAuthorizeAttribute>()
            .AsWebApiAuthorizationFilterFor <ApiController>()
            .PropertiesAutowired()
            .InstancePerRequest();
            builder.RegisterType <YpAuthorizeAttribute>()
            .AsAuthorizationFilterFor <Controller>()
            .PropertiesAutowired()
            .InstancePerRequest();
            //单个注册
            //builder.RegisterType<YpAPIAuthorizeAttribute>().PropertiesAutowired().InstancePerRequest();
            //builder.RegisterType<YpAuthorizeAttribute>().PropertiesAutowired().InstancePerRequest();
        }
Example #18
0
        /// <summary>
        /// Register services and interfaces
        /// </summary>
        /// <param name="builder">Container builder</param>
        /// <param name="typeFinder">Type finder</param>
        /// <param name="config">Config</param>
        public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder, NopConfig config)
        {
            builder.Register(c =>
                             //register FakeHttpContext when HttpContext is not available
                             HttpContext.Current != null ?
                             (new HttpContextWrapper(HttpContext.Current) as HttpContextBase) :
                             (new FakeHttpContext("~/") as HttpContextBase))
            .As <HttpContextBase>()
            .InstancePerLifetimeScope();
            builder.Register(c => c.Resolve <HttpContextBase>().Request)
            .As <HttpRequestBase>()
            .InstancePerLifetimeScope();
            builder.Register(c => c.Resolve <HttpContextBase>().Response)
            .As <HttpResponseBase>()
            .InstancePerLifetimeScope();
            builder.Register(c => c.Resolve <HttpContextBase>().Server)
            .As <HttpServerUtilityBase>()
            .InstancePerLifetimeScope();
            builder.Register(c => c.Resolve <HttpContextBase>().Session)
            .As <HttpSessionStateBase>()
            .InstancePerLifetimeScope();

            //web helper
            builder.RegisterType <WebHelper>().As <IWebHelper>().InstancePerLifetimeScope();
            //user agent helper
            builder.RegisterType <UserAgentHelper>().As <IUserAgentHelper>().InstancePerLifetimeScope();


            //controllers
            builder.RegisterApiControllers(typeFinder.GetAssemblies().ToArray());

            //data layer
            var dataSettingsManager  = new DataSettingsManager();
            var dataProviderSettings = dataSettingsManager.LoadSettings();

            builder.Register(c => dataSettingsManager.LoadSettings()).As <DataSettings>();
            builder.Register(x => new EfDataProviderManager(x.Resolve <DataSettings>())).As <BaseDataProviderManager>().InstancePerDependency();


            builder.Register(x => x.Resolve <BaseDataProviderManager>().LoadDataProvider()).As <IDataProvider>().InstancePerDependency();

            if (dataProviderSettings != null && dataProviderSettings.IsValid())
            {
                var efDataProviderManager = new EfDataProviderManager(dataSettingsManager.LoadSettings());
                var dataProvider          = efDataProviderManager.LoadDataProvider();
                dataProvider.InitConnectionFactory();

                builder.Register <IDbContext>(c => new NopObjectContext(dataProviderSettings.DataConnectionString)).InstancePerLifetimeScope();
            }
            else
            {
                builder.Register <IDbContext>(c => new NopObjectContext(dataSettingsManager.LoadSettings().DataConnectionString)).InstancePerLifetimeScope();
            }


            builder.RegisterGeneric(typeof(EfRepository <>)).As(typeof(IRepository <>)).InstancePerLifetimeScope();

            //plugins
            builder.RegisterType <PluginFinder>().As <IPluginFinder>().InstancePerLifetimeScope();
            builder.RegisterType <OfficialFeedManager>().As <IOfficialFeedManager>().InstancePerLifetimeScope();

            //cache managers
            if (config.RedisCachingEnabled)
            {
                builder.RegisterType <RedisConnectionWrapper>().As <IRedisConnectionWrapper>().SingleInstance();
                builder.RegisterType <RedisCacheManager>().As <ICacheManager>().Named <ICacheManager>("nop_cache_static").InstancePerLifetimeScope();
            }
            else
            {
                builder.RegisterType <MemoryCacheManager>().As <ICacheManager>().Named <ICacheManager>("nop_cache_static").SingleInstance();
            }
            //builder.RegisterType<PerRequestCacheManager>().As<ICacheManager>().Named<ICacheManager>("nop_cache_per_request").InstancePerLifetimeScope();

            if (config.RunOnAzureWebApps)
            {
                builder.RegisterType <AzureWebAppsMachineNameProvider>().As <IMachineNameProvider>().SingleInstance();
            }
            else
            {
                builder.RegisterType <DefaultMachineNameProvider>().As <IMachineNameProvider>().SingleInstance();
            }

            //work context
            builder.RegisterType <WebWorkContext>().As <IWorkContext>().InstancePerLifetimeScope();
            //store context
            builder.RegisterType <APIStoreContext>().As <IStoreContext>().InstancePerLifetimeScope();

            //services
            builder.RegisterType <BackInStockSubscriptionService>().As <IBackInStockSubscriptionService>().InstancePerLifetimeScope();
            builder.RegisterType <CategoryService>().As <ICategoryService>().InstancePerLifetimeScope();
            builder.RegisterType <CompareProductsService>().As <ICompareProductsService>().InstancePerLifetimeScope();
            builder.RegisterType <RecentlyViewedProductsService>().As <IRecentlyViewedProductsService>().InstancePerLifetimeScope();
            builder.RegisterType <ManufacturerService>().As <IManufacturerService>().InstancePerLifetimeScope();
            builder.RegisterType <PriceFormatter>().As <IPriceFormatter>().InstancePerLifetimeScope();
            builder.RegisterType <ProductAttributeFormatter>().As <IProductAttributeFormatter>().InstancePerLifetimeScope();
            builder.RegisterType <ProductAttributeParser>().As <IProductAttributeParser>().InstancePerLifetimeScope();
            builder.RegisterType <ProductAttributeService>().As <IProductAttributeService>().InstancePerLifetimeScope();
            builder.RegisterType <ProductService>().As <IProductService>().InstancePerLifetimeScope();
            builder.RegisterType <CopyProductService>().As <ICopyProductService>().InstancePerLifetimeScope();
            builder.RegisterType <SpecificationAttributeService>().As <ISpecificationAttributeService>().InstancePerLifetimeScope();
            builder.RegisterType <ProductTemplateService>().As <IProductTemplateService>().InstancePerLifetimeScope();
            builder.RegisterType <CategoryTemplateService>().As <ICategoryTemplateService>().InstancePerLifetimeScope();
            builder.RegisterType <ManufacturerTemplateService>().As <IManufacturerTemplateService>().InstancePerLifetimeScope();
            builder.RegisterType <TopicTemplateService>().As <ITopicTemplateService>().InstancePerLifetimeScope();
            //use static cache (between HTTP requests)
            builder.RegisterType <ProductTagService>().As <IProductTagService>()
            .WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
            .InstancePerLifetimeScope();

            builder.RegisterType <AddressAttributeFormatter>().As <IAddressAttributeFormatter>().InstancePerLifetimeScope();
            builder.RegisterType <AddressAttributeParser>().As <IAddressAttributeParser>().InstancePerLifetimeScope();
            builder.RegisterType <AddressAttributeService>().As <IAddressAttributeService>().InstancePerLifetimeScope();
            builder.RegisterType <AddressService>().As <IAddressService>().InstancePerLifetimeScope();
            builder.RegisterType <AffiliateService>().As <IAffiliateService>().InstancePerLifetimeScope();
            builder.RegisterType <VendorService>().As <IVendorService>().InstancePerLifetimeScope();
            builder.RegisterType <SearchTermService>().As <ISearchTermService>().InstancePerLifetimeScope();
            builder.RegisterType <GenericAttributeService>().As <IGenericAttributeService>().InstancePerLifetimeScope();
            builder.RegisterType <FulltextService>().As <IFulltextService>().InstancePerLifetimeScope();
            builder.RegisterType <MaintenanceService>().As <IMaintenanceService>().InstancePerLifetimeScope();

            builder.RegisterType <CustomerAttributeFormatter>().As <ICustomerAttributeFormatter>().InstancePerLifetimeScope();
            builder.RegisterType <CustomerAttributeParser>().As <ICustomerAttributeParser>().InstancePerLifetimeScope();
            builder.RegisterType <CustomerAttributeService>().As <ICustomerAttributeService>().InstancePerLifetimeScope();
            builder.RegisterType <CustomerService>().As <ICustomerService>().InstancePerLifetimeScope();
            builder.RegisterType <CustomerRegistrationService>().As <ICustomerRegistrationService>().InstancePerLifetimeScope();
            builder.RegisterType <CustomerReportService>().As <ICustomerReportService>().InstancePerLifetimeScope();

            //use static cache (between HTTP requests)
            builder.RegisterType <PermissionService>().As <IPermissionService>()
            .WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
            .InstancePerLifetimeScope();
            //use static cache (between HTTP requests)
            builder.RegisterType <AclService>().As <IAclService>()
            .WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
            .InstancePerLifetimeScope();
            //use static cache (between HTTP requests)
            builder.RegisterType <PriceCalculationService>().As <IPriceCalculationService>()
            .WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
            .InstancePerLifetimeScope();

            builder.RegisterType <GeoLookupService>().As <IGeoLookupService>().InstancePerLifetimeScope();
            builder.RegisterType <CountryService>().As <ICountryService>().InstancePerLifetimeScope();
            builder.RegisterType <CurrencyService>().As <ICurrencyService>().InstancePerLifetimeScope();
            builder.RegisterType <MeasureService>().As <IMeasureService>().InstancePerLifetimeScope();
            builder.RegisterType <StateProvinceService>().As <IStateProvinceService>().InstancePerLifetimeScope();

            builder.RegisterType <StoreService>().As <IStoreService>().InstancePerLifetimeScope();
            //use static cache (between HTTP requests)
            builder.RegisterType <StoreMappingService>().As <IStoreMappingService>()
            .WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
            .InstancePerLifetimeScope();

            //use static cache (between HTTP requests)
            builder.RegisterType <DiscountService>().As <IDiscountService>()
            .WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
            .InstancePerLifetimeScope();

            //use static cache (between HTTP requests)
            builder.RegisterType <SettingService>().As <ISettingService>()
            .WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
            .InstancePerLifetimeScope();
            builder.RegisterSource(new SettingsSource());

            //use static cache (between HTTP requests)
            builder.RegisterType <LocalizationService>().As <ILocalizationService>()
            .WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
            .InstancePerLifetimeScope();

            //use static cache (between HTTP requests)
            builder.RegisterType <LocalizedEntityService>().As <ILocalizedEntityService>()
            .WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
            .InstancePerLifetimeScope();
            builder.RegisterType <LanguageService>().As <ILanguageService>().InstancePerLifetimeScope();

            builder.RegisterType <DownloadService>().As <IDownloadService>().InstancePerLifetimeScope();
            //picture service
            var useAzureBlobStorage = !String.IsNullOrEmpty(config.AzureBlobStorageConnectionString);

            if (useAzureBlobStorage)
            {
                //Windows Azure BLOB
                builder.RegisterType <AzurePictureService>().As <IPictureService>().InstancePerLifetimeScope();
            }
            else
            {
                //standard file system
                builder.RegisterType <PictureService>().As <IPictureService>().InstancePerLifetimeScope();
            }

            builder.RegisterType <MessageTemplateService>().As <IMessageTemplateService>().InstancePerLifetimeScope();
            builder.RegisterType <QueuedEmailService>().As <IQueuedEmailService>().InstancePerLifetimeScope();
            builder.RegisterType <NewsLetterSubscriptionService>().As <INewsLetterSubscriptionService>().InstancePerLifetimeScope();
            builder.RegisterType <CampaignService>().As <ICampaignService>().InstancePerLifetimeScope();
            builder.RegisterType <EmailAccountService>().As <IEmailAccountService>().InstancePerLifetimeScope();
            builder.RegisterType <WorkflowMessageService>().As <IWorkflowMessageService>().InstancePerLifetimeScope();
            builder.RegisterType <MessageTokenProvider>().As <IMessageTokenProvider>().InstancePerLifetimeScope();
            builder.RegisterType <Tokenizer>().As <ITokenizer>().InstancePerLifetimeScope();
            builder.RegisterType <EmailSender>().As <IEmailSender>().InstancePerLifetimeScope();

            builder.RegisterType <CheckoutAttributeFormatter>().As <ICheckoutAttributeFormatter>().InstancePerLifetimeScope();
            builder.RegisterType <CheckoutAttributeParser>().As <ICheckoutAttributeParser>().InstancePerLifetimeScope();
            builder.RegisterType <CheckoutAttributeService>().As <ICheckoutAttributeService>().InstancePerLifetimeScope();
            builder.RegisterType <GiftCardService>().As <IGiftCardService>().InstancePerLifetimeScope();
            builder.RegisterType <OrderService>().As <IOrderService>().InstancePerLifetimeScope();
            builder.RegisterType <OrderReportService>().As <IOrderReportService>().InstancePerLifetimeScope();
            builder.RegisterType <OrderProcessingService>().As <IOrderProcessingService>().InstancePerLifetimeScope();
            builder.RegisterType <OrderTotalCalculationService>().As <IOrderTotalCalculationService>().InstancePerLifetimeScope();
            builder.RegisterType <ReturnRequestService>().As <IReturnRequestService>().InstancePerLifetimeScope();
            builder.RegisterType <RewardPointService>().As <IRewardPointService>().InstancePerLifetimeScope();
            builder.RegisterType <ShoppingCartService>().As <IShoppingCartService>().InstancePerLifetimeScope();
            builder.RegisterType <CustomNumberFormatter>().As <ICustomNumberFormatter>().InstancePerLifetimeScope();

            builder.RegisterType <PaymentService>().As <IPaymentService>().InstancePerLifetimeScope();

            builder.RegisterType <EncryptionService>().As <IEncryptionService>().InstancePerLifetimeScope();
            builder.RegisterType <FormsAuthenticationService>().As <IAuthenticationService>().InstancePerLifetimeScope();


            //use static cache (between HTTP requests)
            builder.RegisterType <UrlRecordService>().As <IUrlRecordService>()
            .WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
            .InstancePerLifetimeScope();

            builder.RegisterType <ShipmentService>().As <IShipmentService>().InstancePerLifetimeScope();
            builder.RegisterType <ShippingService>().As <IShippingService>().InstancePerLifetimeScope();
            builder.RegisterType <DateRangeService>().As <IDateRangeService>().InstancePerLifetimeScope();

            builder.RegisterType <TaxCategoryService>().As <ITaxCategoryService>().InstancePerLifetimeScope();
            builder.RegisterType <TaxService>().As <ITaxService>().InstancePerLifetimeScope();

            builder.RegisterType <DefaultLogger>().As <ILogger>().InstancePerLifetimeScope();

            //use static cache (between HTTP requests)
            builder.RegisterType <CustomerActivityService>().As <ICustomerActivityService>()
            .WithParameter(ResolvedParameter.ForNamed <ICacheManager>("nop_cache_static"))
            .InstancePerLifetimeScope();

            bool databaseInstalled = DataSettingsHelper.DatabaseIsInstalled();

            if (!databaseInstalled)
            {
                //installation service
                if (config.UseFastInstallationService)
                {
                    builder.RegisterType <SqlFileInstallationService>().As <IInstallationService>().InstancePerLifetimeScope();
                }
                else
                {
                    builder.RegisterType <CodeFirstInstallationService>().As <IInstallationService>().InstancePerLifetimeScope();
                }
            }

            builder.RegisterType <ForumService>().As <IForumService>().InstancePerLifetimeScope();

            builder.RegisterType <PollService>().As <IPollService>().InstancePerLifetimeScope();
            builder.RegisterType <BlogService>().As <IBlogService>().InstancePerLifetimeScope();
            builder.RegisterType <WidgetService>().As <IWidgetService>().InstancePerLifetimeScope();
            builder.RegisterType <TopicService>().As <ITopicService>().InstancePerLifetimeScope();
            builder.RegisterType <NewsService>().As <INewsService>().InstancePerLifetimeScope();

            builder.RegisterType <DateTimeHelper>().As <IDateTimeHelper>().InstancePerLifetimeScope();
            builder.RegisterType <SitemapGenerator>().As <ISitemapGenerator>().InstancePerLifetimeScope();

            builder.RegisterType <ScheduleTaskService>().As <IScheduleTaskService>().InstancePerLifetimeScope();

            builder.RegisterType <ExportManager>().As <IExportManager>().InstancePerLifetimeScope();
            builder.RegisterType <ImportManager>().As <IImportManager>().InstancePerLifetimeScope();
            builder.RegisterType <PdfService>().As <IPdfService>().InstancePerLifetimeScope();

            builder.RegisterType <ExternalAuthorizer>().As <IExternalAuthorizer>().InstancePerLifetimeScope();
            builder.RegisterType <OpenAuthenticationService>().As <IOpenAuthenticationService>().InstancePerLifetimeScope();



            //Register event consumers
            var consumers = typeFinder.FindClassesOfType(typeof(IConsumer <>)).ToList();

            foreach (var consumer in consumers)
            {
                builder.RegisterType(consumer)
                .As(consumer.FindInterfaces((type, criteria) =>
                {
                    var isMatch = type.IsGenericType && ((Type)criteria).IsAssignableFrom(type.GetGenericTypeDefinition());
                    return(isMatch);
                }, typeof(IConsumer <>)))
                .InstancePerLifetimeScope();
            }
            builder.RegisterType <EventPublisher>().As <IEventPublisher>().SingleInstance();
            builder.RegisterType <SubscriptionService>().As <ISubscriptionService>().SingleInstance();
        }
        public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            //HTTP context and other related stuff
            builder.Register(c => new HttpContextWrapper(HttpContext.Current) as HttpContextBase)
                .As<HttpContextBase>()
                .InstancePerHttpRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Request)
                .As<HttpRequestBase>()
                .InstancePerHttpRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Response)
                .As<HttpResponseBase>()
                .InstancePerHttpRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Server)
                .As<HttpServerUtilityBase>()
                .InstancePerHttpRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Session)
                .As<HttpSessionStateBase>()
                .InstancePerHttpRequest();

            //web helper
            //builder.RegisterType<WebHelper>().As<IWebHelper>().InstancePerHttpRequest();

            //controllers
            builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());

            //data layer
            //var dataSettingsManager = new DataSettingsManager();
            //var dataProviderSettings = dataSettingsManager.LoadSettings();
            //builder.Register(c => dataSettingsManager.LoadSettings()).As<DataSettings>();
            //builder.Register(x => new EfDataProviderManager(x.Resolve<DataSettings>())).As<BaseDataProviderManager>().InstancePerDependency();

            //builder.Register(x => (IEfDataProvider)x.Resolve<BaseDataProviderManager>().LoadDataProvider()).As<IDataProvider>().InstancePerDependency();
            //builder.Register(x => (IEfDataProvider)x.Resolve<BaseDataProviderManager>().LoadDataProvider()).As<IEfDataProvider>().InstancePerDependency();

            //if (dataProviderSettings != null && dataProviderSettings.IsValid())
            //{
            //    var efDataProviderManager = new EfDataProviderManager(dataSettingsManager.LoadSettings());
            //    var dataProvider = (IEfDataProvider)efDataProviderManager.LoadDataProvider();
            //    dataProvider.InitConnectionFactory();

            //    builder.Register<IDbContext>(c => new NopObjectContext(dataProviderSettings.DataConnectionString)).InstancePerHttpRequest();
            //}
            //else
            //{
            //    builder.Register<IDbContext>(c => new NopObjectContext(dataSettingsManager.LoadSettings().DataConnectionString)).InstancePerHttpRequest();
            //}

            builder.Register<IDbContext>(c => new Inspiration.DataAccess.ManageContext())
                .InstancePerHttpRequest();

            builder.RegisterGeneric(typeof(EfRepository<>)).As(typeof(IRepository<>)).InstancePerHttpRequest();

            //plugins
            //builder.RegisterType<PluginFinder>().As<IPluginFinder>().InstancePerHttpRequest();

            //cache manager
            builder.RegisterType<MemoryCacheManager>().As<ICacheManager>().Named<ICacheManager>("core_cache_static").SingleInstance();
            //builder.RegisterType<PerRequestCacheManager>().As<ICacheManager>().Named<ICacheManager>("core_cache_per_request").InstancePerHttpRequest();

            //work context
            //builder.RegisterType<WebWorkContext>().As<IWorkContext>().InstancePerHttpRequest();

            //services

            //builder.RegisterType<CustomerService>().As<ICustomerService>().InstancePerHttpRequest();

            //HTML Editor services
            //builder.RegisterType<NetAdvDirectoryService>().As<INetAdvDirectoryService>().InstancePerHttpRequest();
            //builder.RegisterType<NetAdvImageService>().As<INetAdvImageService>().InstancePerHttpRequest();

            //Register event consumers
            //var consumers = typeFinder.FindClassesOfType(typeof(IConsumer<>)).ToList();
            //foreach (var consumer in consumers)
            //{
            //    builder.RegisterType(consumer)
            //        .As(consumer.FindInterfaces((type, criteria) =>
            //        {
            //            var isMatch = type.IsGenericType && ((Type)criteria).IsAssignableFrom(type.GetGenericTypeDefinition());
            //            return isMatch;
            //        }, typeof(IConsumer<>)))
            //        .InstancePerHttpRequest();
            //}
            //builder.RegisterType<EventPublisher>().As<IEventPublisher>().SingleInstance();
            //builder.RegisterType<SubscriptionService>().As<ISubscriptionService>().SingleInstance();
        }
        public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            //HTTP context and other related stuff
            builder.Register(c =>
                //register FakeHttpContext when HttpContext is not available
                //HttpContext.Current != null ?
                (new HttpContextWrapper(HttpContext.Current) as HttpContextBase)
                //(new FakeHttpContext("~/") as HttpContextBase)
                )
                .As<HttpContextBase>()
                .InstancePerRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Request)
                .As<HttpRequestBase>()
                .InstancePerRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Response)
                .As<HttpResponseBase>()
                .InstancePerRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Server)
                .As<HttpServerUtilityBase>()
                .InstancePerRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Session)
                .As<HttpSessionStateBase>()
                .InstancePerRequest();

            //web helper
            //builder.RegisterType<WebHelper>().As<IWebHelper>().InstancePerRequest();

            var assemblies = typeFinder.GetAssemblies().ToArray();

            //controllers
            builder.RegisterControllers(assemblies);
            //ApiControllers
            builder.RegisterApiControllers(assemblies);

            //View
            //builder.RegisterSource(new ViewRegistrationSource());

            //data layer
            var dataSettingsManager = new DataSettingsManager();
            var dataProviderSettings = dataSettingsManager.LoadSettings();
            builder.Register(c => dataSettingsManager.LoadSettings()).As<DataSettings>();
            builder.Register(x => new EfDataProviderManager(x.Resolve<DataSettings>())).As<BaseDataProviderManager>().InstancePerDependency();


            builder.Register(x => x.Resolve<BaseDataProviderManager>().LoadDataProvider()).As<IDataProvider>().InstancePerDependency();

            if (dataProviderSettings != null && dataProviderSettings.IsValid())
            {
                var efDataProviderManager = new EfDataProviderManager(dataSettingsManager.LoadSettings());
                var dataProvider = efDataProviderManager.LoadDataProvider();
                //dataProvider.InitConnectionFactory();
                ((SqlServerDataProvider)dataProvider).InitDatabase();

                builder.Register<IDbContext>(c => new EfDbContext(dataProviderSettings.DataConnectionString)).InstancePerRequest();
            }
            else
            {
                builder.Register<IDbContext>(c => new EfDbContext(dataSettingsManager.LoadSettings().DataConnectionString)).InstancePerRequest();
            }


            builder.RegisterGeneric(typeof(EfRepository<>)).As(typeof(IRepository<>)).InstancePerRequest();

            builder.RegisterAssemblyTypes(assemblies)
                .Where(t => typeof (IDependency).IsAssignableFrom(t) && t != typeof (IDependency))
                .AsImplementedInterfaces()
                .InstancePerRequest();
            builder.RegisterAssemblyTypes(assemblies)
                .Where(t => typeof (ISingletonDependency).IsAssignableFrom(t) && t != typeof (ISingletonDependency))
                .AsImplementedInterfaces()
                .SingleInstance();

            //IWorkContext
            builder.RegisterType<WorkContext>().As<IWorkContext>().InstancePerRequest();

            //filter
            builder.RegisterFilterProvider(); //todo:使用YpDependencyResolver时此方法会报空,用官方自带的不会
            builder.RegisterWebApiFilterProvider(GlobalConfiguration.Configuration);
            
            //注册YpHnadleError
            //全局注册
            builder.RegisterType<YpHandleErrorAttribute>().AsExceptionFilterFor<Controller>().SingleInstance();
            builder.RegisterType<YpAPIHandleErrorAttribute>().AsWebApiExceptionFilterFor<ApiController>().SingleInstance();
            //单个注册
            //builder.RegisterType<YpHandleErrorAttribute>().SingleInstance();
            //builder.RegisterType<YpAPIHandleErrorAttribute>().SingleInstance();

            //注册YpAuthorizeAttribute
            //全局注册
            builder.RegisterType<YpAPIAuthorizeAttribute>()
                .AsWebApiAuthorizationFilterFor<ApiController>()
                .PropertiesAutowired()
                .InstancePerRequest();
            builder.RegisterType<YpAuthorizeAttribute>()
                .AsAuthorizationFilterFor<Controller>()
                .PropertiesAutowired()
                .InstancePerRequest();
            //单个注册
            //builder.RegisterType<YpAPIAuthorizeAttribute>().PropertiesAutowired().InstancePerRequest();
            //builder.RegisterType<YpAuthorizeAttribute>().PropertiesAutowired().InstancePerRequest();
        }
Example #21
0
        public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            //HTTP context and other related stuff
            builder.Register(c =>
                //register FakeHttpContext when HttpContext is not available
                HttpContext.Current != null ?
                (new HttpContextWrapper(HttpContext.Current) as HttpContextBase) :
                (new FakeHttpContext("~/") as HttpContextBase))
                .As<HttpContextBase>()
                .InstancePerHttpRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Request)
                .As<HttpRequestBase>()
                .InstancePerHttpRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Response)
                .As<HttpResponseBase>()
                .InstancePerHttpRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Server)
                .As<HttpServerUtilityBase>()
                .InstancePerHttpRequest();
            builder.Register(c => c.Resolve<HttpContextBase>().Session)
                .As<HttpSessionStateBase>()
                .InstancePerHttpRequest();

            //controllers
            builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());
            builder.RegisterType<ObjectContext>().As<IDbContext>().InstancePerHttpRequest();

            //builder.RegisterType<UserService>().As<IUserService>().InstancePerHttpRequest();
            //builder.RegisterType<UserRoleService>().As<IUserRoleService>().InstancePerHttpRequest();
            builder.RegisterType<CarSellerTypeService>().As<ICarSellerTypeService>().InstancePerHttpRequest();
            builder.RegisterType<BodyTypeService>().As<IBodyTypeService>().InstancePerHttpRequest();
            builder.RegisterType<CarSellingOnService>().As<ICarSellingOnService>().InstancePerHttpRequest();

            builder.RegisterType<AuctionHouseSaleService>().As<IAuctionHouseSaleService>().InstancePerHttpRequest();
            builder.RegisterType<AuctionHouseCarSellingVehicleImagesMoreService>().As<IAuctionHouseCarSellingVehicleImagesMoreService>().InstancePerHttpRequest();

            builder.RegisterType<CarModelService>().As<ICarModelService>().InstancePerHttpRequest();
            builder.RegisterType<MakeService>().As<IMakeService>().InstancePerHttpRequest();
            builder.RegisterType<EngineSizeService>().As<IEngineSizeService>().InstancePerHttpRequest();
            builder.RegisterType<TransmissionTypeService>().As<ITransmissionTypeService>().InstancePerHttpRequest();
            builder.RegisterType<ServiceHistoryAuctionService>().As<IServiceHistoryAuctionService>().InstancePerHttpRequest();
            builder.RegisterType<FuelTypeService>().As<IFuelTypeService>().InstancePerHttpRequest();
            builder.RegisterType<InteriorTrimService>().As<IInteriorTrimService>().InstancePerHttpRequest();
            builder.RegisterType<CheckStatusService>().As<ICheckStatusService>().InstancePerHttpRequest();

            builder.RegisterType<CountryService>().As<ICountryService>().InstancePerHttpRequest();
            builder.RegisterType<CarSellerVehicleInfoService>().As<ICarSellerVehicleInfoService>().InstancePerHttpRequest();
            builder.RegisterType<CarSellerMoreDetailService>().As<ICarSellerMoreDetailService>().InstancePerHttpRequest();
            builder.RegisterType<CarSellerVehicleImagesService>().As<ICarSellerVehicleImagesService>().InstancePerHttpRequest();
            builder.RegisterType<CarBuyerInfoService>().As<ICarBuyerInfoService>().InstancePerHttpRequest();
            builder.RegisterType<AspNetUsersAdditionalInfoService>().As<IAspNetUsersAdditionalInfoService>().InstancePerHttpRequest();
            builder.RegisterType<SellerPersonalInfoService>().As<ISellerPersonalInfoService>().InstancePerHttpRequest();
            builder.RegisterType<CompanyTypeService>().As<ICompanyTypeService>().InstancePerHttpRequest();
            builder.RegisterType<SellerCompanyInfoService>().As<ISellerCompanyInfoService>().InstancePerHttpRequest();
            builder.RegisterType<SellerCompanyLogoService>().As<ISellerCompanyLogoService>().InstancePerHttpRequest();
            builder.RegisterType<CarSellerInfoService>().As<ICarSellerInfoService>().InstancePerHttpRequest();
            builder.RegisterType<AspNetUserService>().As<IAspNetUserService>().InstancePerHttpRequest();
            builder.RegisterType<AuctionHouseService>().As<IAuctionHouseService>().InstancePerHttpRequest();
            builder.RegisterType<AuctionHouseAddEditVehicleService>().As<IAuctionHouseAddEditVehicleService>().InstancePerHttpRequest();
            builder.RegisterType<CarSellerVehicleFuelTypeService>().As<ICarSellerVehicleFuelTypeService>().InstancePerHttpRequest();
            builder.RegisterType<AspNetUserRolesService>().As<IAspNetUserRolesService>().InstancePerHttpRequest();
            builder.RegisterType<AuctionHouseCarSellingVehicleImagesService>().As<IAuctionHouseCarSellingVehicleImagesService>().InstancePerHttpRequest();
            builder.RegisterType<UserStore<ApplicationUser>>().As<IUserStore<ApplicationUser>>().InstancePerHttpRequest();

            builder.RegisterType<RoleStore<IdentityRole>>().As<IRoleStore<IdentityRole>>();
            builder.RegisterType<UserManager<ApplicationUser>>().InstancePerHttpRequest();
            builder.RegisterType<RoleManager<IdentityRole>>().InstancePerHttpRequest();

            builder.RegisterGeneric(typeof(EfRepository<>)).As(typeof(IRepository<>)).InstancePerHttpRequest();
        }
Example #22
0
        public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder)
        {
            string cacheProvider = ConfigurationManager.AppSettings["CacheProvider"];

            if (string.IsNullOrEmpty(cacheProvider) || !Enum.IsDefined(typeof(CacheTypeEnum), cacheProvider))
            {
                cacheProvider = CacheTypeEnum.Memory.ToString();
            }

            builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());

            //hosting environment register
            builder.RegisterType <HttpContextAccessor>().As <IHttpContextAccessor>().SingleInstance();
            builder.RegisterType <DefaultHostEnvironment>().As <IHostEnvironment>().SingleInstance();

            //register logging autofac module
            //builder.RegisterModule(new LoggingModule());

            //Register Data Provider
            //var dataSettingsManager = new DataSettingsManager();
            //var dataProviderSettings = dataSettingsManager.LoadSettings();
            //builder.Register(c => dataSettingsManager.LoadSettings()).As<DataSettings>();

            //switch (dataProviderSettings.DataProvider.ToLower())
            //{
            //    case "linqtosql.sqlserver":
            //        //Register all Linq relation classes
            //        LinqToSqlRegistra.RegisterAll(builder, dataProviderSettings.DataConnectionString);
            //        break;
            //    case "entityframework.sqlserver":

            //        break;
            //    default:
            //        //use linq for default
            //        LinqToSqlRegistra.RegisterAll(builder, dataProviderSettings.DataConnectionString);
            //        break;
            //}

            builder.Register(x => new DatabaseFactory()).As <IDatabaseFactory>().InstancePerHttpRequest();

            #region Register Security Repositories
            builder.RegisterType <UserRepository>().As <IUserRepository>().InstancePerHttpRequest();
            builder.RegisterType <UserRoleRepository>().As <IUserRoleRepository>().InstancePerHttpRequest();
            builder.RegisterType <RoleRepository>().As <IRoleRepository>().InstancePerHttpRequest();
            builder.RegisterType <ResourceRepository>().As <IResourceRepository>().InstancePerHttpRequest();
            builder.RegisterType <PermissionRepository>().As <IPermissionRepository>().InstancePerHttpRequest();
            #endregion

            #region Register Theme Repositories
            builder.RegisterType <ThemeRepository>().As <IThemeRepository>().InstancePerHttpRequest();
            //builder.RegisterType<StoreThemeRepository>().As<IStoreThemeRepository>().InstancePerHttpRequest();
            #endregion

            #region Other Repositories
            builder.RegisterType <ThumbnailSettingRepository>().As <IThumbnailSettingRepository>().InstancePerHttpRequest();
            builder.RegisterType <SystemSettingRepository>().As <ISystemSettingRepository>().InstancePerHttpRequest();
            builder.RegisterType <PageRepository>().As <IPageRepository>().InstancePerHttpRequest();
            builder.RegisterType <ArticleRepository>().As <IArticleRepository>().InstancePerHttpRequest();
            builder.RegisterType <CategoryRepository>().As <ICategoryRepository>().InstancePerHttpRequest();
            builder.RegisterType <CategoryTypeRepository>().As <ICategoryTypeRepository>().InstancePerHttpRequest();
            builder.RegisterType <SieuwebArticleRepository>().As <ISieuwebArticleRepository>().InstancePerHttpRequest();
            builder.RegisterType <SieuWebCategoryRepository>().As <ISieuWebCategoryRepository>().InstancePerHttpRequest();

            #endregion

            //register services
            #region Register Services
            builder.RegisterType <UserService>().As <IUserService>().InstancePerHttpRequest();
            builder.RegisterType <AuthorizationService>().As <IAuthorizationService>().InstancePerHttpRequest();
            builder.RegisterType <FormsAuthenticationService>().As <IAuthenticationService>().InstancePerHttpRequest();
            builder.RegisterType <DefaultEncryptionService>().As <IEncryptionService>().SingleInstance();
            builder.RegisterType <ThumbnailSettingService>().As <IThumbnailSettingService>().InstancePerHttpRequest();
            builder.RegisterType <SystemSettingService>().As <ISystemSettingService>().InstancePerHttpRequest();
            builder.RegisterType <PageService>().As <IPageService>().InstancePerHttpRequest();
            builder.RegisterType <ArticleService>().As <IArticleService>().InstancePerHttpRequest();
            builder.RegisterType <CategoryService>().As <ICategoryService>().InstancePerHttpRequest();
            builder.RegisterType <CategoryTypeService>().As <ICategoryTypeService>().InstancePerHttpRequest();
            #endregion


            builder.RegisterType <ThemeService>().As <IThemeService>().InstancePerHttpRequest();

            //register FakeHttpContext when HttpContext is not available
            //builder.Register(c => HttpContext.Current != null ?
            //    (new HttpContextWrapper(HttpContext.Current) as HttpContextBase) :
            //    (new FakeHttpContext("~/") as HttpContextBase))
            //    .As<HttpContextBase>()
            //    .InstancePerHttpRequest();
            //builder.Register(c => c.Resolve<HttpContextBase>().Request)
            //    .As<HttpRequestBase>()
            //    .InstancePerHttpRequest();
            //builder.Register(c => c.Resolve<HttpContextBase>().Response)
            //    .As<HttpResponseBase>()
            //    .InstancePerHttpRequest();
            //builder.Register(c => c.Resolve<HttpContextBase>().Server)
            //    .As<HttpServerUtilityBase>()
            //    .InstancePerHttpRequest();
            //builder.Register(c => c.Resolve<HttpContextBase>().Session)
            //    .As<HttpSessionStateBase>()
            //    .InstancePerHttpRequest();


            //plugins
            //builder.RegisterType<PluginFinder>().As<IPluginFinder>().InstancePerHttpRequest();

            ////cache manager
            builder.RegisterType <MemoryCacheManager>().As <ICacheManager>().Named <ICacheManager>(CacheTypeEnum.Memory.ToString()).InstancePerHttpRequest();
            builder.RegisterType <PerRequestCacheManager>().As <ICacheManager>().Named <ICacheManager>(CacheTypeEnum.PerRequest.ToString()).InstancePerHttpRequest();
            builder.RegisterType <RedisCacheManager>().As <ICacheManager>().Named <ICacheManager>(CacheTypeEnum.Redis.ToString()).InstancePerHttpRequest();

            //work context
            builder.RegisterType <WorkContext>().As <IWorkContext>().InstancePerHttpRequest();

            //builder.RegisterSource(new SettingsSource());

            builder.RegisterType <ThemeProvider>().As <IThemeProvider>().SingleInstance();
            builder.RegisterType <ThemeContext>().As <IThemeContext>().InstancePerHttpRequest();


            //builder.RegisterType<EmbeddedViewResolver>().As<IEmbeddedViewResolver>().SingleInstance();
            builder.RegisterType <RoutePublisher>().As <IRoutePublisher>().SingleInstance();
        }