public static void RegistAll() { var iocBuilder = new Autofac.ContainerBuilder(); iocBuilder.RegisterControllers(Assembly.GetExecutingAssembly()); iocBuilder.RegisterApiControllers(Assembly.GetExecutingAssembly()); //Type baseType = typeof(IH2FBase); var iInterfaces = Assembly.Load("H2F.TEST.Interface"); var implement = Assembly.Load("H2F.TEST.Implement"); iocBuilder.RegisterAssemblyTypes(iInterfaces, implement).AsImplementedInterfaces(); iocBuilder.RegisterType <Student>().As <IPerson>(); iocBuilder.RegisterType <Worker>().Keyed <IPerson>(PersonType.Worker); iocBuilder.RegisterType <Student>().Keyed <IPerson>(PersonType.Student); iocBuilder.RegisterType <Log4net>().As <ILogger>(); var config = GlobalConfiguration.Configuration; iocBuilder.RegisterWebApiFilterProvider(config); IContainer iocContainer = iocBuilder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(iocContainer); System.Web.Mvc.DependencyResolver.SetResolver(new AutofacDependencyResolver(iocContainer)); IocContainerManager.SetContanier(iocContainer); }
private static void SetAutofacContainer(string dbConnectionString) { var builder = new ContainerBuilder(); builder.RegisterControllers(Assembly.GetExecutingAssembly()); builder.RegisterType<DefaultValidationBus>().As<IValidationBus>().InstancePerHttpRequest(); builder.RegisterAssemblyTypes(Assembly.Load("Utilities")).AsImplementedInterfaces().InstancePerHttpRequest(); builder.RegisterType<ScrabbleClubContext>().WithParameter("connectionStringName", dbConnectionString).InstancePerHttpRequest(); var infrastructureDataAccessLayerAssembly = Assembly.Load("DataAccess"); builder.RegisterAssemblyTypes(infrastructureDataAccessLayerAssembly) .Where(t => t.Name.EndsWith("Repository")) .AsImplementedInterfaces().InstancePerHttpRequest(); var domainLayerAssembly = Assembly.Load("Domain"); builder.RegisterAssemblyTypes(domainLayerAssembly) .Where(t => t.Name.EndsWith("Service")) .AsImplementedInterfaces() .InstancePerHttpRequest(); var applicationLayerAssembly = Assembly.Load("Application"); builder.RegisterAssemblyTypes(applicationLayerAssembly) .AsClosedTypesOf(typeof (IValidationHandler<>)).InstancePerHttpRequest(); builder.RegisterAssemblyTypes(applicationLayerAssembly) .Where(t => t.Name.EndsWith("Service")) .AsImplementedInterfaces() .InstancePerHttpRequest(); builder.RegisterFilterProvider(); IContainer container = builder.Build(); DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); }
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder) { builder.RegisterType<ShippingByWeightService>().As<IShippingByWeightService>().InstancePerHttpRequest(); //data layer var dataSettingsManager = new DataSettingsManager(); var dataProviderSettings = dataSettingsManager.LoadSettings(); if (dataProviderSettings != null && dataProviderSettings.IsValid()) { //register named context builder.Register<IDbContext>(c => new ShippingByWeightObjectContext(dataProviderSettings.DataConnectionString)) .Named<IDbContext>("nop_object_context_shipping_weight_zip") .InstancePerHttpRequest(); builder.Register<ShippingByWeightObjectContext>(c => new ShippingByWeightObjectContext(dataProviderSettings.DataConnectionString)) .InstancePerHttpRequest(); } else { //register named context builder.Register<IDbContext>(c => new ShippingByWeightObjectContext(c.Resolve<DataSettings>().DataConnectionString)) .Named<IDbContext>("nop_object_context_shipping_weight_zip") .InstancePerHttpRequest(); builder.Register<ShippingByWeightObjectContext>(c => new ShippingByWeightObjectContext(c.Resolve<DataSettings>().DataConnectionString)) .InstancePerHttpRequest(); } //override required repository with our custom context builder.RegisterType<EfRepository<ShippingByWeightRecord>>() .As<IRepository<ShippingByWeightRecord>>() .WithParameter(ResolvedParameter.ForNamed<IDbContext>("nop_object_context_shipping_weight_zip")) .InstancePerHttpRequest(); }
protected override void Load(Autofac.ContainerBuilder builder) { builder.RegisterType <RabbitMQOptions>().AsSelf(); builder.RegisterType <ConnectionPool>().AsSelf().SingleInstance(); builder.RegisterType <RabbitBaseQueue>().AsSelf().SingleInstance(); builder.RegisterType <RabbitMQConsumerClientFactory>().AsSelf().SingleInstance(); }
static void Main(string[] args) { var containerBuilder = new ContainerBuilder(); containerBuilder.RegisterType<Cpu>().As<ICpu>().SingleInstance(); containerBuilder.RegisterType<Emulator>().As<IEmulator>(); containerBuilder.RegisterType<Memory>().As<IMemory>().SingleInstance(); containerBuilder.RegisterType<Ppu>().As<IPpu>(); var instructionTypes = Assembly.GetExecutingAssembly().GetTypes().Where(f => typeof(IInstruction).IsAssignableFrom(f) && !f.IsAbstract).ToArray(); containerBuilder.RegisterTypes(instructionTypes) .As<IInstruction>(); var container = containerBuilder.Build(); var emulator = container.Resolve<IEmulator>(); var memory = container.Resolve<IMemory>(); memory.SetCartridge(new Cartridge("../../roms/nestest.nes")); emulator.Reset(); for (;;) { emulator.Step(); } }
public static void Run() { var builder = new Autofac.ContainerBuilder(); var config = GlobalConfiguration.Configuration; var service = builder.RegisterType<FormularioService>() .As<IFormularioService>(); var factory = builder.RegisterType<DatabaseFactoryFormulario>() .As<IDatabaseFactory>(); var unit = builder.RegisterType<UnitOfWorkGeneric>() .As<IUnitOfWOrkGeneric<IDatabaseFactory>>(); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterWebApiFilterProvider(config); builder.RegisterWebApiModelBinderProvider(); service.InstancePerRequest(); factory.InstancePerRequest(); unit.InstancePerRequest(); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); config.Formatters.Remove(config.Formatters.XmlFormatter); var json = GlobalConfiguration.Configuration.Formatters.JsonFormatter; json.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented; json.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); }
private static void SetupExtensibility(Autofac.ContainerBuilder builder, bool withAspects) { var dynamicProxy = new CastleDynamicProxyProvider(); var aopRepository = new AspectRepository(dynamicProxy); var assemblies = NGS.Utility.AssemblyScanner.GetAssemblies().Where(it => it.FullName.StartsWith("NGS.")); builder.RegisterInstance(new PluginsConfiguration { Assemblies = assemblies }); builder.RegisterType <SystemInitialization>(); builder.RegisterType <AutofacObjectFactory>().As <IObjectFactory>().SingleInstance(); builder.RegisterType <AutofacMefProvider>().As <IExtensibilityProvider>().SingleInstance(); builder.RegisterGeneric(typeof(PluginRepository <>)).As(typeof(IPluginRepository <>)).SingleInstance(); builder.RegisterInstance(aopRepository).As <IAspectRegistrator, IAspectComposer, IInterceptorRegistrator>(); builder.RegisterInstance(dynamicProxy).As <IMixinProvider, IDynamicProxyProvider>(); if (withAspects) { var autofacModules = from type in NGS.Utility.AssemblyScanner.GetAllTypes() where type.IsPublic && typeof(Autofac.Module).IsAssignableFrom(type) && type.GetConstructor(new Type[0]) != null select type; foreach (var m in autofacModules) { builder.RegisterModule((Autofac.Module)Activator.CreateInstance(m)); } builder.RegisterModule(new AspectsModule(aopRepository)); } }
private static void SetIocContainer() { //Implement Autofac var configuration = GlobalConfiguration.Configuration; var builder = new ContainerBuilder(); // Register MVC controllers using assembly scanning. builder.RegisterControllers(Assembly.GetExecutingAssembly()); // Register MVC controller and API controller dependencies per request. builder.RegisterType<UnitOfWork>().As<IUnitOfWork>().InstancePerDependency(); builder.RegisterType<DatabaseFactory>().As<IDatabaseFactory>().InstancePerLifetimeScope(); // Register service builder.RegisterAssemblyTypes(typeof(ProfileService).Assembly) .Where(t => t.Name.EndsWith("Service")) .AsImplementedInterfaces().InstancePerDependency(); // Register repository builder.RegisterAssemblyTypes(typeof(ProfileRepository).Assembly) .Where(t => t.Name.EndsWith("Repository")) .AsImplementedInterfaces().InstancePerDependency(); var container = builder.Build(); //for MVC Controller Set the dependency resolver implementation. var resolverMvc = new AutofacDependencyResolver(container); System.Web.Mvc.DependencyResolver.SetResolver(resolverMvc); }
protected override void Load(ContainerBuilder builder) { builder.RegisterType<ConfigManager>().As<IConfigManager>() .WithParameter(new NamedParameter("navigation", this.Navigation)); builder.RegisterType<SecurityManager>().As<ISecurityManager>(); }
/// <summary> /// Override to add registrations to the container. /// </summary> /// <remarks> /// Note that the ContainerBuilder parameter is unique to this module. /// </remarks> /// <param name="builder">The builder through which components can be /// registered.</param> protected override void Load(ContainerBuilder builder) { builder.RegisterModule<WebWorkContextModule>(); builder.RegisterType<DefaultHttpContextAccessor>().As<IHttpContextAccessor>().SingleInstance(); builder.RegisterType<ShellRoute>().InstancePerDependency(); }
/// <summary> /// 加载配置 /// </summary> /// <param name="builder">容器生成器</param> protected override void Load( ContainerBuilder builder ) { base.Load( builder ); //builder.RegisterInstance( new Context() ); -----该方法也可 builder.RegisterType<Context>().InstancePerLifetimeScope(); builder.RegisterType<Operation3>().As<IOperation3>(); builder.RegisterType<Operation4>().As<IOperation4>(); }
protected override void Load(ContainerBuilder builder) { builder.RegisterModule(new RepositoryModule()); builder.RegisterType(typeof(SampleArchContext)).As(typeof(DbContext)).InstancePerLifetimeScope(); builder.RegisterType(typeof(UnitOfWork)).As(typeof(IUnitOfWork)).InstancePerRequest(); }
protected override void Load(ContainerBuilder builder) { builder.RegisterType<ViewFactory>().As<IViewFactory>().SingleInstance(); builder.RegisterType<Navigator>().As<INavigator>().SingleInstance(); builder.Register<INavigation>(ctx => App.Current.MainPage.Navigation).SingleInstance(); }
public static Autofac.ContainerBuilder AddTransactionProcessingServices(this Autofac.ContainerBuilder services) { services.RegisterType <LockService>() .As <ILockService>() .WithParameter("connectionString", ConfigurationManager.ConnectionStrings["DB"].ConnectionString); services.RegisterType <TransactionTriggers.TransactionTriggerWorker>() .Keyed <IWorker>("TransactionTriggerWorker") .InstancePerDependency(); services.RegisterType <TransactionTriggers.TransactionTriggerPool>() .Keyed <IWorkerPool>("TransactionTrigger") .WithParameter("threadCount", 1) .WithParameter("timeOut", TimeSpan.FromSeconds(5)) .SingleInstance(); //services.RegisterType<SSBQueueManager>() // .Keyed<IQueueManager>("TransactionTriggerQueue") // .WithParameter("connectionString", ConfigurationManager.ConnectionStrings["DB"].ConnectionString) // .WithParameter("queueName", "QTransactionTrigger") // .WithParameter("receiveService", "RX_TransactionTrigger") // .SingleInstance(); services.RegisterType <MemoryQueue>() .Keyed <IQueueManager>("TransactionTriggerQueue") .SingleInstance(); return(services); }
protected override void Load(Autofac.ContainerBuilder builder) { builder.RegisterType <FaceComparer>() .As <FaceComparer>() .WithProperty("FaceAlignmentModelPath", GetAbsolutePath(Properties.Settings.Default.FaceAlignModelFile)) .WithProperty("FaceAlignClassifierPath", GetAbsolutePath(Properties.Settings.Default.FaceAlignClassifierFile)) .WithProperty("FaceRepositoryPath", GetAbsolutePath(Properties.Settings.Default.FaceRepositoryPath)) .WithProperty("IlluminateReferenceFilePath", GetAbsolutePath(Properties.Settings.Default.IlluminateRefFilePath)) .PropertiesAutowired(); if (EnableFaceComparer) { if (System.IO.Directory.Exists(PersonOfInterestLibraryPath)) { var personRepository = SuspectsRepositoryManager.LoadFrom(PersonOfInterestLibraryPath); builder.RegisterInstance(personRepository.Peoples) .As <IEnumerable <PersonOfInterest> >() .ExternallyOwned(); } } else { builder.Register(c => new PersonOfInterest[0]).SingleInstance(); builder.RegisterType <NullRepositoryFaceComparer>() .As <IRepositoryFaceComparer>(); } }
private static IContainer CreateContainer(string projectFilePath) { ContainerBuilder builder = new ContainerBuilder(); // Features RegisterFeatures(builder); // Services builder.RegisterType<FileSystemService>().As<IFileSystemService>().SingleInstance(); builder.RegisterType<ProjectService>() .As<IProjectService>() .WithParameter("projectFilePath", projectFilePath) .SingleInstance(); // View Models builder.RegisterType<MainViewModel>().As<IMainViewModel>().SingleInstance(); // Views builder.RegisterType<MainView>() .As<IMainView>() .PropertiesAutowired(PropertyWiringOptions.None) .SingleInstance(); return builder.Build(); }
public TripleTexFacade(int syncSystem, string syncPassword, string username, string password) { _syncSystem = syncSystem; _syncPassword = syncPassword; _username = username; _password = password; // Setup IoC and DI var builder = new ContainerBuilder(); // The JsonService keeps the session cookie and has to have one instance per lifetime builder.RegisterType<JsonService>().As<IJsonService>().InstancePerLifetimeScope(); //builder.RegisterAssemblyTypes() // .Where(r => r.Name.EndsWith("Service")) // .AsImplementedInterfaces(); builder.RegisterType<SyncService>().As<ISyncService>(); builder.RegisterType<CompanyService>().As<ICompanyService>(); builder.RegisterType<OrderService>().As<IOrderService>(); builder.RegisterType<ProductService>().As<IProductService>(); _container = builder.Build(); // Login _container.Resolve<ISyncService>().Login(_syncSystem, _syncPassword, _username, _password); }
public Bootstrapper() { IContainer container = null; var builder = new ContainerBuilder(); builder.RegisterModule(new AgathaClientModule { ContainerFactory = () => container, RequestResponseAssembly = typeof (Nitrogen.Common.AssemblyHook).Assembly }); builder.RegisterModule(new Log4NetModule {SectionName = "CommonLogging.Nitrogen.Client"}); builder.RegisterType<MessageStream>().As<IMessageStream>().SingleInstance(); builder.RegisterType<ShellViewModel>().AsSelf(); builder.RegisterModule(new WPFModule()); builder.RegisterType<WPFStartable>().AsSelf(); builder.RegisterType<ClientStartable>().AsSelf(); // DataExplorer builder.RegisterModule(new DataExplorerModule()); builder.RegisterType<DataExplorerStartable>().AsSelf(); // Build the container container = builder.Build(); // TODO : Ideally change this, so it isn't resolved like this container.Resolve<WPFStartable>().Start(); container.Resolve<ClientStartable>().Start(); container.Resolve<DataExplorerStartable>().Start(); }
static int Main(string[] args) { var options = ParseCommandLine(args); if (options == null) { return(1); } var logger = new LoggerConfiguration() .MinimumLevel.Debug() .WriteTo.ColoredConsole() .CreateLogger(); var builder = new Autofac.ContainerBuilder(); builder.RegisterType <TestClient>().As <ITestApi>(); builder.RegisterInstance(logger).As <ILogger>(); builder.RegisterInstance(options).As <IProgramOptions>(); builder.RegisterType <TestClient>().AsSelf(); //builder.RegisterType<SignalRClient>().AsSelf(); using (var container = builder.Build()) { Run(container).Wait(); } return(0); }
protected override void Load(Autofac.ContainerBuilder builder) { builder.RegisterType <RestApplication>().As <RestApplication, IRestApplication>(); builder.RegisterType <SoapApplication>().As <SoapApplication, ISoapApplication>(); builder.RegisterType <CommandConverter>().As <ICommandConverter>(); SetupExtensibility(builder); if (WithDatabase) { SetupPostgres(builder); } SetupPatterns(builder); SetupSerialization(builder); builder.RegisterType <RepositoryAuthentication>().As <IAuthentication <SecureString>, IAuthentication <string>, IAuthentication <byte[]> >(); builder.RegisterType <RepositoryPrincipalFactory>().As <IPrincipalFactory>(); builder.RegisterType <PermissionManager>().As <IPermissionManager>().SingleInstance(); builder.RegisterType <LogFactory>().As <ILogFactory>().SingleInstance(); builder.RegisterType <NLogLogger>().As <ILogger>(); builder.RegisterType(typeof(ProcessingEngine)).As(typeof(IProcessingEngine)).SingleInstance(); builder.RegisterType <OnContainerBuild>().As <IStartable>(); base.Load(builder); }
private static void SetupExtensibility(Autofac.ContainerBuilder builder) { var dynamicProxy = new CastleDynamicProxyProvider(); var aopRepository = new AspectRepository(dynamicProxy); var dllPlugins = (from key in ConfigurationManager.AppSettings.AllKeys where key.StartsWith("PluginsPath", StringComparison.OrdinalIgnoreCase) let path = ConfigurationManager.AppSettings[key] let pathRelative = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, path) let chosenPath = Directory.Exists(pathRelative) ? pathRelative : path select chosenPath) .ToList(); builder.RegisterInstance(new PluginsConfiguration { Directories = dllPlugins }); builder.RegisterType <SystemInitialization>(); builder.RegisterType <AutofacObjectFactory>().As <IObjectFactory>().SingleInstance(); builder.RegisterType <AutofacMefProvider>().As <IExtensibilityProvider>().SingleInstance(); builder.RegisterGeneric(typeof(PluginRepository <>)).As(typeof(IPluginRepository <>)).SingleInstance(); builder.RegisterInstance(aopRepository).As <IAspectRegistrator, IAspectComposer, IInterceptorRegistrator>(); builder.RegisterInstance(dynamicProxy).As <IMixinProvider, IDynamicProxyProvider>(); if (ConfigurationManager.AppSettings["Revenj.AllowAspects"] == "true") { builder.RegisterModule(new AspectsModule(aopRepository)); } }
public void Register(Autofac.ContainerBuilder builder, SmartConfig config) { builder.RegisterGeneric(typeof(ITmpl <>)).As(typeof(IT <>)).InstancePerLifetimeScope(); builder.RegisterGeneric(typeof(ITmpl <,>)).As(typeof(IT <,>)).InstancePerLifetimeScope(); builder.RegisterType <TestClass>().AsSelf().PropertiesAutowired().SingleInstance(); builder.RegisterType <TestClass2>().AsSelf().PropertiesAutowired().SingleInstance(); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); // Register: create and configure the container _container = BootstrapContainer(); DependencyResolver.SetResolver(new AutofacDependencyResolver(_container)); var builder = new ContainerBuilder(); //var configurationRepository = // new ConfigurationRepository.ConfigurationRepository() as IConfigurationRepository; //builder.Register(c => configurationRepository).As<IConfigurationRepository>().SingleInstance(); builder.RegisterType<StashCoreApiConsumer>().As<IStashCoreApiConsumer>(); builder.RegisterType<PullTrackerRepository>().As<IPullTrackerRepository>(); builder.RegisterType<RequestProcessFacade>().As<IRequestProcessFacade>(); IContainer localContainer = builder.Build(); AutofacHelper.Scope = localContainer; _containerProvider = new ContainerProvider(localContainer); }
// ConfigureContainer is where you can register things directly // with Autofac. This runs after ConfigureServices so the things // here will override registrations made in ConfigureServices. // Don't build the container; that gets done for you by the factory. // ReSharper disable once UnusedMember.Global public void ConfigureContainer(Autofac.ContainerBuilder builder) { // Register your own things directly with Autofac here. Don't // call builder.Populate(), that happens in AutofacServiceProviderFactory // for you. builder.RegisterType <AkkaGameService>() .As <IGameService>() .SingleInstance(); var connectionString = Configuration.GetSection("ConnectionString").Value; builder.RegisterType <CoreWarsDataContext>() .WithParameter("connectionString", connectionString) .As <CoreWarsDataContext>() .AsImplementedInterfaces(); builder.RegisterType <AggregatedCompetitorFactory>(); builder .RegisterType <SelectMaxRandomCollectionSelectionStrategy <IActorRef> >() .AsImplementedInterfaces(); builder.RegisterType <PlayerSet <IActorRef> >() .AsImplementedInterfaces(); builder.RegisterModule <PythonScriptingModule>(); builder.RegisterModule <DilemmaModule>(); builder.RegisterModule <TicTacToeModule>(); }
/// <summary> /// Configures the multitenant dependency container. /// </summary> private static IContainer ConfigureDependencies() { // Register default dependencies in the application container. var builder = new ContainerBuilder(); builder.RegisterType<Consumer>().As<IDependencyConsumer>().InstancePerDependency(); builder.RegisterType<BaseDependency>().As<IDependency>().SingleInstance(); var appContainer = builder.Build(); // Create the multitenant container. var mtc = new MultitenantContainer(_tenantIdentifier, appContainer); // Configure overrides for tenant 1. Tenant 1 registers their dependencies // as instance-per-dependency. mtc.ConfigureTenant('1', b => b.RegisterType<Tenant1Dependency>().As<IDependency>().InstancePerDependency()); // Configure overrides for tenant 2. Tenant 2 registers their dependencies // as singletons. mtc.ConfigureTenant('2', b => b.RegisterType<Tenant2Dependency>().As<IDependency>().SingleInstance()); // Configure overrides for the default tenant. That means the default // tenant will have some different dependencies than other unconfigured // tenants. mtc.ConfigureTenant(null, b => b.RegisterType<DefaultTenantDependency>().As<IDependency>().SingleInstance()); return mtc; }
private void configureIoC() { var builder = new ContainerBuilder(); builder.RegisterControllers(typeof(MvcApplication).Assembly); builder.Register(ctx => LogManager.GetLogger("trace")) .As<Logger>() .InstancePerHttpRequest(); builder.RegisterType<ProcessRunner>() .AsImplementedInterfaces() .InstancePerDependency() ; builder.RegisterType<DotProcessor>() .AsImplementedInterfaces() .SingleInstance() ; builder.RegisterType<Ansi2HtmlConverter>() .AsImplementedInterfaces() .InstancePerDependency() ; var container = builder.Build(); DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); }
public void Init() { var builder = new ContainerBuilder(); builder.RegisterType<TokenManager>().As<ITokenManager>(); builder.RegisterType<TestTokenProvider>().As<ITokenProvider>(); _container = builder.Build(); _tokenManager = _container.Resolve<ITokenManager>(); }
public static void RegisterHandlersWithAutofac(ContainerBuilder containerBuilder, IReadOnlyCollection<MessageRegistration> registrations) { var handlers = registrations.Select(x => x.Handler).Distinct(); var piplelineHandlers = registrations.Select(x => x.Pipeline).Distinct().SelectMany(x => x).Distinct(); RegisterLeafHandlers(containerBuilder, handlers); RegisterPipelineHandlers(containerBuilder, piplelineHandlers); foreach (var registration in registrations) { if (registration.Dependancies.Any()) { foreach (var dependancy in registration.Dependancies) { containerBuilder.RegisterType(dependancy).AsSelf(); } } if (registration.ScopedDependancies.Any()) { foreach (var dependancy in registration.ScopedDependancies) { containerBuilder.RegisterType(dependancy).AsSelf().AsImplementedInterfaces().InstancePerLifetimeScope(); } } } }
private static IContainer RegisterServices(ContainerBuilder builder) { builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // EF PSMContext builder.RegisterType<PSMContext>() .As<DbContext>() .InstancePerRequest(); builder.RegisterType<DbFactory>() .As<IDbFactory>() .InstancePerRequest(); builder.RegisterType<UnitOfWork>() .As<IUnitOfWork>() .InstancePerRequest(); builder.RegisterGeneric(typeof(EntityBaseRepository<>)) .As(typeof(IEntityBaseRepository<>)) .InstancePerRequest(); Container = builder.Build(); return Container; }
private static void ConfigureAutofac(HttpConfiguration config, IIssueStore issueStore) { var builder = new ContainerBuilder(); if (issueStore == null) { builder.RegisterType<InMemoryIssueStore>() .As<IIssueStore>() .InstancePerLifetimeScope(); } else { builder.RegisterInstance(issueStore); } builder.RegisterType<IssueStateFactory>() .As<IStateFactory<Issue, IssueState>>() .InstancePerLifetimeScope(); builder.RegisterType<IssueLinkFactory>() .InstancePerLifetimeScope(); builder.RegisterHttpRequestMessage(config); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); var container = builder.Build(); var resolver = new AutofacWebApiDependencyResolver(container); config.DependencyResolver = resolver; }
public void RegisterDefaultServices() { var builder = new ContainerBuilder(); builder.RegisterInstance(container); builder.RegisterType<AutofacServiceLocator>() .As<IServiceLocator>() .SingleInstance(); builder.RegisterAssemblyTypes(typeof(IServiceBus).Assembly) .AssignableTo<IBusConfigurationAware>() .As<IBusConfigurationAware>() .SingleInstance(); builder.RegisterType<DefaultReflection>() .As<IReflection>() .SingleInstance(); builder.RegisterType(config.SerializerType) .As<IMessageSerializer>() .SingleInstance(); builder.RegisterType<EndpointRouter>() .As<IEndpointRouter>() .SingleInstance(); foreach(var module in config.MessageModules) { builder.RegisterType(module) .Named<string>(module.FullName) .As(typeof(IMessageModule)) .SingleInstance(); } builder.Update(container); foreach(var busConfigurationAware in container.Resolve<IEnumerable<IBusConfigurationAware>>()) busConfigurationAware.Configure(config, this); }
/// <summary> /// Registers the modules type bindings /// </summary> /// <param name="builder"> /// The container builder. /// </param> protected override void Load(ContainerBuilder builder) { // Resource locator builder.RegisterType<DocsResourceLocatorConfig>() .As<IResourceLocatorConfig>() .Named<IResourceLocatorConfig>("docs"); // Fields Configuration builder.RegisterType<DocsFieldInfoConfig>() .As<IDocsFieldInfoConfig>() .Named<IDocsFieldInfoConfig>("docs"); // Content Types Configuration builder.RegisterType<DocsContentTypeInfoConfig>() .As<IDocsContentTypeInfoConfig>() .Named<IDocsContentTypeInfoConfig>("docs"); // Lists Configuration builder.RegisterType<DocsListInfoConfig>() .As<IDocsListInfoConfig>() .Named<IDocsListInfoConfig>("docs"); // Image Renditions builder.RegisterType<DocsImageRenditionInfoConfig>() .As<IDocsImageRenditionInfoConfig>() .Named<IDocsImageRenditionInfoConfig>("docs"); }
public void Configuration(IAppBuilder app) { var config = new HttpConfiguration(); config.Routes.MapHttpRoute( "DefaultApi", "api/{controller}/{id}", new {id = RouteParameter.Optional}); var builder = new ContainerBuilder(); // Register Web API controller in executing assembly. builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // Register a logger service to be used by the controller and middleware. builder.Register(c => new Logger()).As<ILogger>().InstancePerRequest(); // Autofac will add middleware to IAppBuilder in the order registered. // The middleware will execute in the order added to IAppBuilder. builder.RegisterType<FirstMiddleware>().InstancePerRequest(); builder.RegisterType<SecondMiddleware>().InstancePerRequest(); var container = builder.Build(); // Create and assign a dependency resolver for Web API to use. config.DependencyResolver = new AutofacWebApiDependencyResolver(container); // This should be the first middleware added to the IAppBuilder. app.UseAutofacMiddleware(container); // Make sure the Autofac lifetime scope is passed to Web API. app.UseAutofacWebApi(config); app.UseWebApi(config); }
public void Init() { string databaseFileName = Path.GetTempFileName(); IDataServicesProviderFactory dataServicesProviderFactory = new DataServicesProviderFactory(new[] { new Meta<CreateDataServicesProvider>( (dataFolder, connectionString) => new SqlCeDataServicesProvider(dataFolder, connectionString), new Dictionary<string, object> {{"ProviderName", "SqlCe"}}) }); var builder = new ContainerBuilder(); builder.RegisterInstance(new ShellBlueprint()); builder.RegisterInstance(new ShellSettings { Name = ShellSettings.DefaultName, DataTablePrefix = "Test", DataProvider = "SqlCe" }); builder.RegisterInstance(dataServicesProviderFactory).As<IDataServicesProviderFactory>(); builder.RegisterInstance(AppDataFolderTests.CreateAppDataFolder(Path.GetDirectoryName(databaseFileName))).As<IAppDataFolder>(); builder.RegisterType<SqlCeDataServicesProvider>().As<IDataServicesProvider>(); builder.RegisterType<SessionConfigurationCache>().As<ISessionConfigurationCache>(); builder.RegisterType<SessionFactoryHolder>().As<ISessionFactoryHolder>(); builder.RegisterType<CompositionStrategy>().As<ICompositionStrategy>(); builder.RegisterType<ExtensionManager>().As<IExtensionManager>(); builder.RegisterType<SchemaCommandGenerator>().As<ISchemaCommandGenerator>(); builder.RegisterType<StubCacheManager>().As<ICacheManager>(); builder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>(); builder.RegisterType<StubAsyncTokenProvider>().As<IAsyncTokenProvider>(); builder.RegisterType<StubHostEnvironment>().As<IHostEnvironment>(); _container = builder.Build(); _extensionManager = _container.Resolve<IExtensionManager>(); _schemaCommandGenerator = _container.Resolve<ISchemaCommandGenerator>(); }
public void Register(ContainerBuilder builder, SmartConfig config) { builder.RegisterType<Context.SampleDbContext>().As<DbContext>().InstancePerLifetimeScope(); builder.RegisterType<Context.OtherDbContext>().As<Context.IOtherDbContext>().InstancePerLifetimeScope(); builder.RegisterGeneric(typeof(EFRepository<>)).As(typeof(IRepository<>)).InstancePerLifetimeScope(); builder.RegisterGeneric(typeof(EFRepository<,>)).As(typeof(IRepository<,>)).InstancePerLifetimeScope(); }
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder) { Singleton<IDependencyResolver>.Instance = new DependencyResolver(); string collectionString = "Data Source=.;Initial Catalog=demo;User ID=sa;Password=sa;Trusted_Connection=False;"; builder.Register<IDbContext>(c => new WaterMoonContext(collectionString)).PerLifeStyle(ComponentLifeStyle.LifetimeScope); builder.RegisterGeneric(typeof(EfRepository<>)).As(typeof(IRepository<>)).PerLifeStyle(ComponentLifeStyle.LifetimeScope); builder.RegisterGeneric(typeof(PagedList<>)).As(typeof(IPagedList<>)).PerLifeStyle(ComponentLifeStyle.LifetimeScope); builder.RegisterType<DefualtMapping>().As<IMapping>().SingleInstance(); //注册所有实现IConsumer<>类型的对象 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<>))) .PerLifeStyle(ComponentLifeStyle.LifetimeScope); } builder.RegisterType<EventPublisher>().As<IEventPublisher>().SingleInstance(); builder.RegisterType<SubscriptionService>().As<ISubscriptionService>().SingleInstance(); builder.RegisterType<DemoService>().As<IDemoService>().PerLifeStyle(ComponentLifeStyle.LifetimeScope); }
protected override void Load(ContainerBuilder builder) { builder.RegisterType<ServicioDatosImpl>().As<IServicioDatos>().SingleInstance(); builder.RegisterType<Session>().SingleInstance(); builder.RegisterType<Login>(); builder.RegisterType<Principal>(); builder.RegisterType<Registro>(); builder.RegisterType<NuevoBlocView>(); builder.RegisterType<LoginViewModel>(); builder.RegisterType<PrincipalViewModel>(); builder.RegisterType<RegistroViewModel>(); builder.RegisterType<NuevoBlocViewModel>(); //Registrar la instancia de una funcion que va a devolver una pagina builder.RegisterInstance<Func<Page>>(() => { //saber que pagina está en primer plano (pagina principalen este momento) y le digo que me lo de como una pagina maestrodetalle var masterP = App.Current.MainPage as MasterDetailPage; //si no se puede convertir como masterdetailpage me das el mainpage var page = masterP != null ? masterP.Detail : App.Current.MainPage; //creo objeto navigation de tipo pagina var navigation = page as IPageContainer<Page>; //devuelvo la pagina actual o la maestra (le pregunto al objeto si es la pagina principal) return navigation != null ? navigation.CurrentPage : page; }); }
protected override void Load(ContainerBuilder builder) { base.Load(builder); builder.RegisterType<ApplicationDatabase>() .As<IApplicationDatabase>() .SingleInstance(); builder .RegisterType<DatabaseUpgradeDetector>() .As<IDatabaseUpgradeDetector>() .SingleInstance(); builder .RegisterType<SqlDatabaseProvider>() .As<IDatabaseProvider>() .Named<IDatabaseProvider>("sql") .WithMetadata<IDatabaseProviderMetadata>(c => c.For(m => m.Name, "Sql")); builder .RegisterType<SqlCeDatabaseProvider>() .As<IDatabaseProvider>() .Named<IDatabaseProvider>("sqlce") .WithMetadata<IDatabaseProviderMetadata>(c => c.For(m => m.Name, "SqlCe")); }
private static IContainer RegisterServices(ContainerBuilder builder) { builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // EF DbContext builder.RegisterType<EntitiesContext>() .As<DbContext>() .InstancePerApiRequest(); // Register repositories by using Autofac's OpenGenerics feature // More info: http://code.google.com/p/autofac/wiki/OpenGenerics builder.RegisterGeneric(typeof(EntityRepository<>)) .As(typeof(IEntityRepository<>)) .InstancePerApiRequest(); // Services builder.RegisterType<CryptoService>() .As<ICryptoService>() .InstancePerApiRequest(); builder.RegisterType<MembershipService>() .As<IMembershipService>() .InstancePerApiRequest(); builder.RegisterType<ShipmentService>() .As<IShipmentService>() .InstancePerApiRequest(); return builder.Build(); }
private void RegisterServices(ContainerBuilder builder) { // repositories //override required repository with our custom context builder.RegisterType<EfRepository<GroupRule>>() .As<IRepository<GroupRule>>() .WithParameter(ResolvedParameter.ForNamed<IDbContext>(TAX_GROUPS_CONTEXT_NAME)) .InstancePerLifetimeScope(); // repositories //override required repository with our custom context builder.RegisterType<EfRepository<TaxClass>>() .As<IRepository<TaxClass>>() .WithParameter(ResolvedParameter.ForNamed<IDbContext>(TAX_GROUPS_CONTEXT_NAME)) .InstancePerLifetimeScope(); // repositories //override required repository with our custom context builder.RegisterType<EfRepository<MemberGroup>>() .As<IRepository<MemberGroup>>() .WithParameter(ResolvedParameter.ForNamed<IDbContext>(TAX_GROUPS_CONTEXT_NAME)) .InstancePerLifetimeScope(); // repositories //override required repository with our custom context builder.RegisterType<EfRepository<TaxRule>>() .As<IRepository<TaxRule>>() .WithParameter(ResolvedParameter.ForNamed<IDbContext>(TAX_GROUPS_CONTEXT_NAME)) .InstancePerLifetimeScope(); /////////////////////////////////////////////////////////////////////////////////////////////// // services //builder.RegisterType<GroupDealService>().As<IGroupDealService>().InstancePerLifetimeScope(); /////////////////////////////////////////////////////////////////////////////////////////////// }
protected override void Load(ContainerBuilder builder) { builder.RegisterType<VendingMachineDbContext>() .As<DbContext>() .AsSelf() .InstancePerLifetimeScope(); builder.RegisterGeneric(typeof (EntityFrameworkUnitOfWork<>)) .As(typeof (UnitOfWork<>)) .InstancePerDependency(); builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly()) .Where(x => x.IsClosedTypeOf(typeof (IEntityFactory<,>))) .AsImplementedInterfaces() .InstancePerDependency(); builder.RegisterType<CoinsRefundedEventCommitter>() .As(typeof (EntityFrameworkTrackedEventCommitter<UserVendingMachineAggregationEntity, CoinsRefundedEvent>)) .InstancePerDependency(); builder.RegisterType<GoodsBuyedEventCommitter>() .As(typeof (EntityFrameworkTrackedEventCommitter<UserVendingMachineAggregationEntity, GoodsBuyedEvent>)) .InstancePerDependency(); //builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly()) // .Where(x => x.IsClosedTypeOf(typeof (ITrackedEventCommitter<,>))) // .As(typeof(EntityFrameworkTrackedEventCommitter<,>)) // .AsImplementedInterfaces() // .InstancePerDependency(); }
private static void RegisterInputProviders(Autofac.ContainerBuilder builder) { builder.RegisterInstance(new TextReaderInputProvider(System.Console.In, System.Console.Out)).As <IInputProvider>(); builder.RegisterType <DemoInputProvider>().As <IInputProvider>(); builder.RegisterType <InputProviderFactory>().AsImplementedInterfaces(); }
public static void Launch() { var builder = new Autofac.ContainerBuilder(); builder.RegisterType <Tasks.TaskException>(); builder.RegisterType <Tasks.TaskSyncLineShiftPerfLastShift>(); builder.RegisterType <Tasks.TaskOEEActionManagement>(); builder.RegisterType <UnitOfWork>() .As <IUnitOfWork>() .InstancePerBackgroundJob(); builder.RegisterType <DatabaseFactory>() .As <IDatabaseFactory>() .InstancePerBackgroundJob(); builder.RegisterAssemblyTypes(typeof(SystemFunctionRepository).Assembly) .Where(t => t.Name.EndsWith("Repository")) .AsImplementedInterfaces() .InstancePerBackgroundJob(); builder.RegisterAssemblyTypes(typeof(SystemService).Assembly) .Where(t => t.Name.EndsWith("Service")) .AsImplementedInterfaces() .InstancePerBackgroundJob(); Hangfire.GlobalConfiguration.Configuration.UseAutofacActivator(builder.Build()); }
public ContainerBuilderHelper() { Autofac.ContainerBuilder builder = new Autofac.ContainerBuilder(); builder.RegisterType<LS.Cores.SysLogsService>().As<LS.Cores.ISysLogs>(); builder.RegisterType<LS.Cores.SysMenuService>().As<LS.Cores.ISysMenu>(); builder.RegisterType<LS.Cores.SysDictionaryService>().As<LS.Cores.ISysDictionary>(); container = builder.Build(); }
private static void RegisterDependencies(Autofac.ContainerBuilder builder) { builder.RegisterType <ConfigProvider>().AsImplementedInterfaces().SingleInstance(); builder.RegisterType <WordsCalculator>().AsImplementedInterfaces().InstancePerDependency(); builder.RegisterType <FormattedOutputBuilder>().AsImplementedInterfaces(); RegisterInputProviders(builder); }
public void Build() { Autofac.ContainerBuilder builder = new Autofac.ContainerBuilder(); builder.RegisterType <DatabaseHandler>().As <IDatabaseHandler>().SingleInstance(); builder.RegisterType <AuthentificationManager>().As <IAuthentificationManager>().SingleInstance(); builder.RegisterType <KickTaskConnection>().SingleInstance(); Container = builder.Build(); }
protected override void Register(Autofac.ContainerBuilder builder) { builder.RegisterType <PlacementFileParser>().As <IPlacementFileParser>(); builder.RegisterType <StubCacheManager>().As <ICacheManager>(); builder.RegisterType <StubParallelCacheContext>().As <IParallelCacheContext>(); builder.RegisterType <InMemoryWebSiteFolder>().As <IWebSiteFolder>() .As <InMemoryWebSiteFolder>().InstancePerLifetimeScope(); }
public IContainer CreateContainer() { var builder = new Autofac.ContainerBuilder(); builder.RegisterType<MyCommandHandler>().As<ICommandHandler<AnotherCommand>>(); builder.RegisterType<MyCommandHandler>().As<ICommandHandler<MyCommand>>(); builder.RegisterGeneric(typeof(CompositeCommandHandler<>)).As(typeof(ICommandHandler<>)); return builder.Build(); }
/// <summary> /// 注册实例类型(type) /// 【RegisterType】 /// </summary> /// <param name="builder"></param> /// <returns></returns> protected override Autofac.ContainerBuilder RegisterFunc(Autofac.ContainerBuilder builder) { builder.RegisterType <StudentRepository>(); builder.RegisterType <StudentAppService>(); //除了泛型,还可以传入type //builder.RegisterType(typeof(StudentService)); //builder.RegisterType(typeof(StudentRepository)); return(builder); }
public static Autofac.ContainerBuilder AddSearchIndexerServices(this Autofac.ContainerBuilder services) { services.RegisterType <IndexQueue>().As <IIndexQueue>().SingleInstance(); services.RegisterType <IndexWorker>().As <IIndexWorker>().SingleInstance(); services.RegisterType <IndexRegister>().As <IIndexRegister>().SingleInstance(); services.RegisterType <IndexStore>().As <IIndexStore>().InstancePerDependency(); services.RegisterType <SearchService>().As <ISearchService>().InstancePerDependency(); return(services); }
public static Autofac.ContainerBuilder AddDomainServices(this Autofac.ContainerBuilder services) { services.RegisterType <HR1Context>().As <IHR1Context>().InstancePerDependency(); services.RegisterType <AccountingEntitySetupManager>().As <IAccountingEntitySetupManager>().InstancePerDependency(); //services.RegisterType<SequenceNumberGeneator>().As<ISequenceNumberGeneator>().InstancePerDependency(); return(services); }
/// <summary> /// 注册实例类型(type)和服务类型(interface) /// 【RegisterType】+【As】 /// </summary> /// <param name="builder"></param> /// <returns></returns> protected override Autofac.ContainerBuilder RegisterFunc(Autofac.ContainerBuilder builder) { builder.RegisterType <StudentRepository>() //指定实例类型 .As <IStudentRepository>(); //指定服务类型 builder.RegisterType(typeof(StudentAppService)) .As(typeof(IStudentAppService)) .AsSelf() .AsImplementedInterfaces(); //以其实现的所有接口作为服务类型 return(builder); }
/// <summary> /// 命名实例注册 /// </summary> /// <param name="builder"></param> /// <returns></returns> protected override Autofac.ContainerBuilder RegisterFunc(Autofac.ContainerBuilder builder) { builder.RegisterType <MyService>() .As <IMyService>() .InstancePerLifetimeScope(); builder.RegisterType <MyOtherService>() .Named <IMyService>("other") .InstancePerLifetimeScope(); return(builder); }
/// <summary> /// 属性注入方法2 /// 【RegisterType】+【PropertiesAutowired】 /// </summary> /// <param name="builder"></param> /// <returns></returns> protected override Autofac.ContainerBuilder RegisterFunc(Autofac.ContainerBuilder builder) { builder.RegisterType <TeacherRepository>() .AsImplementedInterfaces(); builder.RegisterType <TeacherAppService>() .PropertiesAutowired() .AsImplementedInterfaces(); return(builder); }
static App() { var builder = new Autofac.ContainerBuilder(); builder.RegisterType <LoginUser>().AsSelf().SingleInstance(); builder.RegisterType <RootData>().AsSelf().SingleInstance(); var container = builder.Build(); LifetimeScope = container.BeginLifetimeScope(typeof(App).ToString()); }
protected override void Load(Autofac.ContainerBuilder builder) { builder.RegisterType <PostgresDataAccessObjectService>().As <IDataAccessObjectService>(); builder.RegisterType <WebObjectService>().As <IWebObjectService>(); builder.Register(c => new BranchOfficeDbContext() ).As <BranchOfficeDbContext>().SingleInstance(); builder.RegisterType <ConfigurationService>().As <IConfigurationService>(); builder.RegisterType <HQAPIClient>().As <IHQAPIClient>(); builder.RegisterType <SynchronizatorService>(). As <ISynchronizatorService>().SingleInstance(); }
static void Aop() { Autofac.ContainerBuilder containerBuilder = new Autofac.ContainerBuilder(); containerBuilder.RegisterType <PrintTimeHandler>(); containerBuilder.RegisterType <DaoImpl>().As <Dao>().InterceptedBy(typeof(PrintTimeHandler)).EnableClassInterceptors(); var life = containerBuilder.Build().BeginLifetimeScope(); var dao = life.Resolve <Dao>(); dao.insert(); dao.update(); dao.delete(); }
/// <summary> /// Registers the comm service. /// </summary> /// <param name="builder">The builder.</param> protected static void RegisterCommService(Autofac.ContainerBuilder builder) { //comm service builder.RegisterType <iPow.Infrastructure.Crosscutting.Comm.Service.CityInfoService>() .As <iPow.Infrastructure.Crosscutting.Comm.Service.ICityInfoService>().InstancePerHttpRequest(); builder.RegisterType <iPow.Infrastructure.Crosscutting.Comm.Service.DiscountService>() .As <iPow.Infrastructure.Crosscutting.Comm.Service.IDiscountService>().InstancePerHttpRequest(); builder.RegisterType <iPow.Infrastructure.Crosscutting.Comm.Service.LocationService>() .As <iPow.Infrastructure.Crosscutting.Comm.Service.ILocationService>().InstancePerHttpRequest(); builder.RegisterType <iPow.Infrastructure.Crosscutting.Comm.Service.SightInfoSearchService>() .As <iPow.Infrastructure.Crosscutting.Comm.Service.ISightInfoSearchService>().InstancePerHttpRequest(); }
private IServiceProvider ConfigAutofacDI(IServiceCollection services) { var builder = new Autofac.ContainerBuilder(); builder.RegisterType <RequestIdFactory>().As <IRequestIdFactory>().SingleInstance(); builder.RegisterType <RequestId>().As <IRequestId>(); builder.Populate(services); this.ApplicationContainer = builder.Build(); return(new AutofacServiceProvider(this.ApplicationContainer)); }
private static void SetupPostgres(Autofac.ContainerBuilder builder, string cs) { builder.RegisterInstance(new NGS.DatabasePersistence.Postgres.ConnectionInfo(cs)); builder.RegisterType <PostgresQueryManager>().As <IDatabaseQueryManager>().InstancePerLifetimeScope(); builder.RegisterType <PostgresDatabaseQuery>().As <IPostgresDatabaseQuery>(); builder.Register(c => c.Resolve <IDatabaseQueryManager>().CreateQuery()).As <IDatabaseQuery>().InstancePerLifetimeScope(); builder.RegisterType <PostgresDatabaseNotification>().As <IDataChangeNotification, IEagerNotification>().SingleInstance(); builder.RegisterType <PostgresObjectFactory>().As <IPostgresConverterRepository, IPostgresConverterFactory>().SingleInstance(); builder.RegisterType <NGS.DatabasePersistence.Postgres.QueryGeneration.QueryExecutor>(); }