static void RegisterApplicationComponents(ContainerBuilder builder, WebConfigSettings settings)
{
builder.RegisterModule<NLogModule>();
builder.RegisterType<ViewInfo>().InstancePerHttpRequest();
builder.RegisterType<SingleWebServerApplicationState>().As<IApplicationState>().InstancePerHttpRequest();
builder.RegisterType<DefaultApplicationBus>().As<IApplicationBus>().InstancePerHttpRequest();
builder.RegisterInstance(settings).As<ISettings>().SingleInstance();
//NOTE: registering a single RavenDB document store instance for the entire application, and a single instance per HttpRequest for the IDocumentSession
builder.Register(x => RavenDBConfig.CreateDocumentStore()).As<IDocumentStore>().SingleInstance();
builder.Register(x => x.Resolve<IDocumentStore>().OpenSession()).As<IDocumentSession>().InstancePerHttpRequest();
builder.RegisterType<AuthenticationCallbackProvider>().As<IAuthenticationCallbackProvider>();
builder.RegisterType<CookieCache>().As<ICache>();
builder.RegisterType<SimpleAuthenticationController>().As<SimpleAuthenticationController>().InstancePerHttpRequest();
builder.RegisterType<DefaultSecurityEncoder>().As<ISecurityEncoder>().SingleInstance();
builder.RegisterType<DefaultSlugConverter>().As<ISlugConverter>().SingleInstance();
if(settings.RunningInProduction()) {
builder.RegisterType<CloudinaryImageStorage>().As<IImageStorage>().SingleInstance();
} else {
builder.RegisterType<LocalImageStorage>().As<IImageStorage>().SingleInstance();
}
}
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 void Application_Start() {
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
Store = new DocumentStore() { ConnectionStringName = "Onboarding" };
Store.Initialize();
var builder = new ContainerBuilder();
Store.Conventions.RegisterIdConvention<User>((dbname, commands, user) => "users/" + user.UserName);
builder.Register(c => {
var store = new DocumentStore {
ConnectionStringName = "Onboarding",
DefaultDatabase = "Onboarding"
}.Initialize();
return store;
}).As<IDocumentStore>().SingleInstance();
builder.Register(c => c.Resolve<IDocumentStore>().OpenAsyncSession()).As<IAsyncDocumentSession>().InstancePerLifetimeScope();
}
protected override void Load(ContainerBuilder builder)
{
builder.Register<IDealRepository>(x => new DealRepository(x.ResolveNamed<ISessionFactory>("ProjectSessionFactory"))).SingleInstance();
builder.Register<IProjectRepository>(x => new ProjectRepository(x.ResolveNamed<ISessionFactory>("ProjectSessionFactory"))).SingleInstance();
builder.RegisterAssemblyTypes(this.ThisAssembly)
.Where(t => t.GetInterface(typeof(IView).Name) != null && !t.IsAbstract && t.IsPublic)
.AsImplementedInterfaces()
.SingleInstance()
.OnActivated(x =>
{
x.Context.Resolve<IEventBroker>().Subscribe(x.Instance);
});
builder.RegisterAssemblyTypes(this.ThisAssembly)
.Where(t => t.GetInterface(typeof(IController).Name) != null && !t.IsAbstract && t.IsPublic)
.AsImplementedInterfaces()
.SingleInstance()
.OnActivated(x =>
{
x.Context.Resolve<IEventBroker>().Subscribe(x.Instance);
});
builder.RegisterAssemblyTypes(typeof(ProjectService).Assembly)
.Where(t => t.GetInterface(typeof(IService).Name) != null && !t.IsAbstract && t.IsPublic)
.AsImplementedInterfaces()
.SingleInstance()
.OnActivated(x =>
{
x.Context.Resolve<IEventBroker>().Subscribe(x.Instance);
});
base.Load(builder);
}
protected override void Load(ContainerBuilder builder)
{
builder
.Register<IEventStoreConnection>(c => InitEventStore(c))
.SingleInstance();
builder
.Register<UserCredentials>(c => new UserCredentials(
Environment.GetEnvironmentVariable("EVENTSTORE_USERNAME") ?? "admin",
Environment.GetEnvironmentVariable("EVENTSTORE_PASSWORD") ?? "changeit"
))
.SingleInstance();
builder
.Register<IEventStore>(c => new OuroEventStore(
c.Resolve<ILoggerFactory>().CreateLogger<IEventStore>(),
c.Resolve<IEventStoreConnection>()
))
.AsSelf()
.As<IEventStore>()
.SingleInstance();
builder
.Register<OuroStreamFactory>(c => new OuroStreamFactory(
c.Resolve<ILoggerFactory>().CreateLogger<IEventStore>(),
c.Resolve<IEventStoreConnection>(),
c.Resolve<UserCredentials>()
))
.AsSelf()
.As<IBuildStreams>()
.SingleInstance();
}
public void Configuration(IAppBuilder app)
{
var configuration = new ConfigurationService();
var builder = new ContainerBuilder();
builder.Register(c => configuration).As<ConfigurationService>().SingleInstance();
builder.Register(c => configuration.CurrentConfiguration).As<IAppConfiguration>().SingleInstance();
builder.Register(c => HttpContext.Current.GetOwinContext().Authentication).InstancePerRequest();
var container = AutofacBootstrapper.Initialize(builder);
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
// Must register Autofac middleware FIRST!
app.UseAutofacMiddleware(container);
app.UseAutofacMvc();
ConfigureAuth(app, configuration.CurrentConfiguration);
AntiForgeryConfig.UniqueClaimTypeIdentifier = JwtClaimTypes.Subject;
AntiForgeryConfig.RequireSsl = true;
AntiForgeryConfig.CookieName = Prsd.Core.Web.Constants.CookiePrefix + Constants.AntiForgeryCookieName;
MvcHandler.DisableMvcResponseHeader = true;
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
ModelBinders.Binders.DefaultBinder = new TrimModelBinder();
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredAttribute), typeof(WeeeRequiredAttributeAdapter));
ApplicationVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
}
public static void Configure()
{
var builder = new ContainerBuilder();
builder.RegisterControllers(Assembly.GetExecutingAssembly());
//register RavenDb DocumentStore
builder.Register(x =>
{
var store = new DocumentStore { ConnectionStringName = "RavenDb" };
store.Initialize();
IndexCreation.CreateIndexes(Assembly.GetCallingAssembly(), store);
return store;
});
//register RavenDb DocumentSession per Http request and SaveChanges on release of scope
builder.Register(x => x.Resolve<DocumentStore>().OpenSession())
.As<IDocumentSession>()
.InstancePerHttpRequest();
//.OnRelease(x => { using (x) { x.SaveChanges(); } });
builder.RegisterType<SupplierNameResolver>().InstancePerHttpRequest();
builder.RegisterType<CategoryNameResolver>().InstancePerHttpRequest();
var container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
public void RegisterRepositories(ContainerBuilder builder)
{
builder.Register(context =>
{
var documentStore = RavenHelper.CreateDocumentStore();
return documentStore;
})
.As<IDocumentStore>()
.SingleInstance();
builder.Register(context => context.Resolve<IDocumentStore>().OpenSession()).As<IDocumentSession>();
builder.RegisterType<RavenBuildRepository>().As<IBuildRepository>();
builder.RegisterType<RavenProjectRepository>().As<IProjectRepository>();
builder.RegisterType<RavenFileRepository>().As<IFileRepository>();
//Bind<IFileStorage>().To<RavenFileStorage_Collection>();
builder.RegisterType<RavenFileStorage_Attachment>().As<IFileStorage>();
builder.RegisterType<RavenAttachmentManager>().As<IRavenAttachmentManager>();
builder.RegisterType<RavenDeployRepository>().As<IDeployRepository>();
builder.RegisterType<RavenDeployStateRepository>().As<IDeployStateRepository>();
builder.RegisterType<RavenSystemLogRepository>().As<ISystemLogRepository>();
builder.RegisterType<RavenMembershipRepository>().As<IMembershipRepository>();
builder.RegisterType<RavenEmailQueueRepository>().As<IEmailQueueRepository>();
builder.RegisterType<RavenCredentialsRepository>().As<ICredentialsRepository>();
builder.RegisterType<RavenSystemSettingsRepository>().As<ISystemSettingsRepository>();
builder.RegisterType<RavenRazorTemplateRepository>().As<IRazorTemplateRepository>();
builder.RegisterType<RavenCleanupRepository>().As<ICleanupRepository>();
builder.RegisterType<RavenOfflineDeploymentRepository>().As<IOfflineDeploymentRepository>();
builder.RegisterType<RavenSystemRoleRepository>().As<ISystemRoleRepository>();
builder.RegisterType<RavenBuildPurgeRuleRepository>().As<IBuildPurgeRuleRepository>();
builder.RegisterType<RavenConnectionSettingRepository>().As<IConnectionSettingRepository>();
builder.RegisterType<RavenPermissionRepository>().As<IPermissionRepository>();
}
/// <summary>
/// Override to add registrations to the container.
/// </summary>
/// <param name="builder">The builder through which components can be
/// registered.</param>
protected override void Load(ContainerBuilder builder)
{
builder.Register(c => BootstrapperParameters.InitFromDomain(AppDomain.CurrentDomain))
.SingleInstance();
builder.RegisterType<UpdatesMonitor>();
builder.RegisterType<VersionDirectoryFinder>();
builder.RegisterType<CurrentAssemblyVersionProvider>().As<IVersionProvider>();
builder.RegisterType<UpdateReceiver>().As<IUpdateReceiver>().AsSelf();
builder.RegisterType<ZipSource>();
builder.RegisterType<ProjectPackager>().As<IProjectPackager>();
builder.RegisterType<TestResultsProcessor>();
builder.RegisterType<TestResultsSerializer>().As<ITestResultsSerializer>().InstancePerLifetimeScope();
builder.Register(c => new RollingLog(c.Resolve<LogConfiguration>().RollingLogItemsCount)).InstancePerLifetimeScope();
builder.RegisterType<ConsoleLog>().InstancePerLifetimeScope();
builder.Register(
c => new CombinedLog(c.Resolve<ConsoleLog>(), c.Resolve<RollingLog>(), c.Resolve<WindowsLog>()))
.As<ILog>()
.SingleInstance();
builder.RegisterType<RealConnectionProvider>().As<IConnectionProvider>().InstancePerLifetimeScope();
builder.RegisterType<NUnitInitializer>().As<ITestSystemInitializer>().InstancePerLifetimeScope();
builder.RegisterType<InstanceTracker>().As<IInstanceTracker>().InstancePerLifetimeScope();
builder.RegisterType<ExceptionCatcher>().InstancePerLifetimeScope();
builder.Register(c => new AssemblyResolver(c.Resolve<ILog>())).InstancePerLifetimeScope();
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(c => new DocumentStoreFactory().CreateStore()).SingleInstance();
builder.Register(c => c.Resolve<IDocumentStore>().OpenSession()).InstancePerLifetimeScope();
builder.RegisterType<BlogFlowRepository>().As<IRepository>().InstancePerLifetimeScope();
}
public static IContainer ConfigureWebApiContainer()
{
Configure();
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType<EmployeeContext>().As<IDataContextAsync>().AsImplementedInterfaces().InstancePerRequest();
containerBuilder.RegisterType<ProtivitiContextProvider<EmployeeContext>>().As<IBreezeUnitofWorkAsync>().AsImplementedInterfaces().InstancePerRequest();
//containerBuilder.Register(c=> new EFContextProvider<ApplicationDbContext>()).As<EFContextProvider<ApplicationDbContext>>().InstancePerRequest();
//containerBuilder.RegisterType<BaseController>().PropertiesAutowired();
containerBuilder.Register(c => new RepositoryProvider(new RepositoryFactories())).As<IRepositoryProvider>().AsImplementedInterfaces().InstancePerRequest();
containerBuilder.RegisterType<Repository<Employee>>().As<IRepositoryAsync<Employee>>().AsImplementedInterfaces().InstancePerRequest();
// containerBuilder.RegisterType<EmployeeService>().As<IEmployeeService>().AsImplementedInterfaces().InstancePerRequest();// InstancePerApiRequest();
containerBuilder.Register(c => new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext())
{
/*Avoids UserStore invoking SaveChanges on every actions.*/
//AutoSaveChanges = false
})).As<UserManager<ApplicationUser>>().InstancePerRequest();
containerBuilder.RegisterApiControllers(System.Reflection.Assembly.GetExecutingAssembly()).PropertiesAutowired();
IContainer container = containerBuilder.Build();
return container;
}
public async Task RegisterNewOrUpdateDetailsAsyncEditExsitingAndShouldReturnOne()
{
ContainerBuilder autoFacBuilder = new ContainerBuilder();
autoFacBuilder.Register(c =>
{
var iHaslContext = Substitute.For<IHaslContext>();
return iHaslContext;
}).InstancePerDependency();
autoFacBuilder.Register(c =>
{
var iEntityFacade = Substitute.For<IDoctorFacade>();
iEntityFacade.GetDetails(Arg.Any<IHaslContext>(), Arg.Any<string>()).Returns(new Doctor { RegisteredUserId = 5 });
iEntityFacade.UpdateAsync(Arg.Any<IHaslContext>(), Arg.Any<Doctor>()).Returns(1);
return iEntityFacade;
}).InstancePerDependency();
autoFacBuilder.RegisterType<DoctorManager>().As<IDoctorManager>().InstancePerDependency();
IContainer iContainer = autoFacBuilder.Build();
var iCurdLogicManager = iContainer.Resolve<IDoctorManager>();
var modifiedCount = await iCurdLogicManager.RegisterNewOrUpdateDetailsAsync(new Doctor()
{
HospitalId = 456789,
RegisteredUserId = 5,
});
Assert.Equal<int>(1, modifiedCount);
}
public static IContainer Configure(WsFederationPluginOptions options, InternalConfiguration internalConfig)
{
if (internalConfig == null) throw new ArgumentNullException("internalConfig");
if (options == null) throw new ArgumentNullException("options");
var factory = options.Factory;
factory.Validate();
var builder = new ContainerBuilder();
// mandatory from factory
builder.Register(factory.CoreSettings);
builder.Register(factory.UserService);
builder.Register(factory.RelyingPartyService);
builder.Register(factory.WsFederationSettings);
// validators
builder.RegisterType<SignInValidator>().AsSelf();
// processors
builder.RegisterType<SignInResponseGenerator>().AsSelf();
builder.RegisterType<MetadataResponseGenerator>().AsSelf();
// general services
builder.RegisterType<CookieMiddlewareTrackingCookieService>().As<ITrackingCookieService>();
builder.RegisterInstance(options).AsSelf();
builder.RegisterInstance(internalConfig).AsSelf();
// load core controller
builder.RegisterApiControllers(typeof(WsFederationController).Assembly);
return builder.Build();
}
private static void RegisterServices(ContainerBuilder builder)
{
builder.Register(x => new EntertainmentSystemDbContext())
.As<DbContext>()
.InstancePerRequest();
builder.Register(x => new HttpCacheService())
.As<ICacheService>()
.InstancePerRequest();
builder.Register(x => new IdentifierProvider())
.As<IIdentifierProvider>()
.InstancePerRequest();
var usersServicesAssembly = Assembly.GetAssembly(typeof(UsersAdminService));
builder.RegisterAssemblyTypes(usersServicesAssembly).AsImplementedInterfaces();
var mediaServicesAssembly = Assembly.GetAssembly(typeof(MediaCategoryService));
builder.RegisterAssemblyTypes(mediaServicesAssembly).AsImplementedInterfaces();
var forumServicesAssembly = Assembly.GetAssembly(typeof(ForumPostService));
builder.RegisterAssemblyTypes(forumServicesAssembly).AsImplementedInterfaces();
var dropboxCloudStorage = Assembly.GetAssembly(typeof(DropboxCloudStorage));
builder.RegisterAssemblyTypes(dropboxCloudStorage).AsImplementedInterfaces();
builder.RegisterGeneric(typeof(DbRepository<>))
.As(typeof(IDbRepository<>))
.InstancePerRequest();
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
.AssignableTo<BaseController>().PropertiesAutowired();
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
var nhConfiguration = new NHibernateConfiguration(ConnectionString);
builder.Register(c => nhConfiguration.GetSessionFactory()).As<ISessionFactory>().SingleInstance();
builder.Register(c => c.Resolve<ISessionFactory>().OpenSession()).As<ISession>().InstancePerHttpRequest();
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(c => CloudStorage
.ForAzureAccount(_account ?? Patch(c.Resolve<CloudStorageAccount>()))
.WithDataSerializer(c.Resolve<IDataSerializer>())
.WithObserver(c.ResolveOptional<IStorageObserver>())
.BuildStorageProviders())
.OnRelease(p => p.QueueStorage.AbandonAll());
builder.Register(c => CloudStorage
.ForAzureAccount(_account ?? Patch(c.Resolve<CloudStorageAccount>()))
.WithDataSerializer(c.Resolve<IDataSerializer>())
.WithObserver(c.ResolveOptional<IStorageObserver>())
.BuildBlobStorage());
builder.Register(c => CloudStorage
.ForAzureAccount(_account ?? Patch(c.Resolve<CloudStorageAccount>()))
.WithDataSerializer(c.Resolve<IDataSerializer>())
.WithObserver(c.ResolveOptional<IStorageObserver>())
.BuildQueueStorage())
.OnRelease(p => p.AbandonAll());
builder.Register(c => CloudStorage
.ForAzureAccount(_account ?? Patch(c.Resolve<CloudStorageAccount>()))
.WithDataSerializer(c.Resolve<IDataSerializer>())
.WithObserver(c.ResolveOptional<IStorageObserver>())
.BuildTableStorage());
builder.Register(c => new NeutralLogStorage
{
BlobStorage = CloudStorage.ForAzureAccount(_account ?? Patch(c.Resolve<CloudStorageAccount>())).WithDataSerializer(new CloudFormatter()).BuildBlobStorage()
});
}
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>()
.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();
builder.RegisterType<SqlServerProvider>().As<IDbProvider>();
builder.RegisterType<MemoryProvider>().Named<ICache>("memory");
var list = typeFinder.FindClassesOfType<ICache>().ToList();
list.ForEach(s=>builder.RegisterType(s));
//list.ForEach(s=>builder.RegisterType<s>());
}
public MainWindow()
{
InitializeComponent();
// Init Autofac.WCF container
builder = new ContainerBuilder();
// Register the channel factory for the service. Make it
// SingleInstance since you don't need a new one each time.
builder
.Register(c => new ChannelFactory<WcfProxies.Proxies.External.IBlogPostService>(
new WSHttpBinding(),
new EndpointAddress("http://localhost:9002/BlogPostService")))
.SingleInstance();
// Register the service interface using a lambda that creates
// a channel from the factory. Include the UseWcfSafeRelease()
// helper to handle proper disposal.
builder
.Register(c => c.Resolve<ChannelFactory<WcfProxies.Proxies.External.IBlogPostService>>()
.CreateChannel())
.As<WcfProxies.Proxies.External.IBlogPostService>()
.UseWcfSafeRelease();
// You can also register other dependencies.
builder.RegisterType<WcfProxies.Proxies.External.BlogPostClientExt>();
container = builder.Build();
}
public ApplicationContainer()
{
var builder = new ContainerBuilder();
//builder.RegisterModule<WhiteboxProfilingModule>();
//default to InstancePerDependency, i.e., they it will make a new
//one each time someone asks for one
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly());
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
.Where(t => t.GetInterfaces().Contains(typeof(ICommand))).InstancePerLifetimeScope();
builder.Register(c => LocalizationManager).SingleInstance();
if (Settings.Default.MruProjects==null)
{
Settings.Default.MruProjects = new MostRecentPathsList();
}
builder.RegisterInstance(Settings.Default.MruProjects).SingleInstance();
//this is to prevent some problems we were getting while waiting for a browser to navigate and being forced to call Application.DoEvents().
//HtmlThumbnailer & ConfigurationDialog, at least, use this.
builder.Register(c => new NavigationIsolator()).InstancePerLifetimeScope();
builder.Register<HtmlThumbNailer>(c => new HtmlThumbNailer(c.Resolve<NavigationIsolator>())).SingleInstance();
builder.Register<BookThumbNailer>(c => new BookThumbNailer(c.Resolve<HtmlThumbNailer>())).SingleInstance();
_container = builder.Build();
Application.ApplicationExit += OnApplicationExit;
}
private static void RegisterConfigurationSections(ContainerBuilder builder)
{
builder.Register(_ => ImportSettings.Current).SingleInstance();
builder.Register(c => c.Resolve<ImportSettings>().General).SingleInstance();
builder.Register(c => c.Resolve<ImportSettings>().Doaj).SingleInstance();
builder.Register(c => c.Resolve<ImportSettings>().Ulrichs).SingleInstance();
}
public static void Setup()
{
var builder = new ContainerBuilder();
builder.RegisterControllers(typeof(MvcApplication).Assembly);
builder.RegisterModelBinders(Assembly.GetExecutingAssembly());
builder.RegisterModelBinderProvider();
builder.RegisterModule<AutofacWebTypesModule>();
builder.RegisterSource(new ViewRegistrationSource());
builder.RegisterFilterProvider();
builder.RegisterType<PremiumCalculationService>().As<IPremiumCalculationService>();
builder.Register(context => new MapperConfiguration(configuration =>
{
configuration.AddProfile(new AutoMapperProfile());
}))
.AsSelf()
.SingleInstance();
builder.Register(context => context.Resolve<MapperConfiguration>()
.CreateMapper(context.Resolve))
.As<IMapper>()
.InstancePerLifetimeScope();
var container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
protected override void Load(Autofac.ContainerBuilder builder)
{
builder.Register((c, p) =>
{
var settings = c.Resolve <MongoSettings>();
return(new MongoClient(settings.ConnectionString));
}).SingleInstance();
builder.Register((c, p) =>
{
var client = c.Resolve <MongoClient>();
var settings = c.Resolve <MongoSettings>();
var database = client.GetDatabase(settings.Database);
return(database);
}).As <IMongoDatabase>();
var assembly = typeof(MongoModule)
.GetTypeInfo()
.Assembly;
builder.RegisterAssemblyTypes(assembly)
.Where(x => x.IsAssignableTo <IMongoRepository>())
.AsImplementedInterfaces()
.InstancePerLifetimeScope();
}
private static void RegisterServices(ContainerBuilder builder)
{
builder.Register(x => new AppDbContext())
.As<DbContext>()
.InstancePerRequest();
builder.Register(x => new HttpCacheService())
.As<ICacheService>()
.InstancePerRequest();
builder.Register(x => new IdentifierProvider())
.As<IIdentifierProvider>()
.InstancePerRequest();
builder.Register(x => new DropdownListService())
.As<IDropdownListService>()
.InstancePerRequest();
var servicesAssembly = Assembly.GetAssembly(typeof(IPostsService));
builder.RegisterAssemblyTypes(servicesAssembly).AsImplementedInterfaces();
builder.RegisterGeneric(typeof(DbRepository<>))
.As(typeof(IDbRepository<>))
.InstancePerRequest();
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
.AssignableTo<BaseController>().PropertiesAutowired();
}
protected override void ConfigureLifetimeScope(ContainerBuilder builder)
{
builder.Register(CreateImageRetrievalSessionFactory)
.SingleInstance();
builder.RegisterType<NHibernateSagaRepository<ImageRetrievalState>>()
.As<ISagaRepository<ImageRetrievalState>>()
.SingleInstance();
builder.RegisterType<AutofacStateMachineActivityFactory>()
.As<IStateMachineActivityFactory>()
.InstancePerLifetimeScope();
builder.RegisterType<SendRetrieveImageCommandConfigurationSettings>()
.As<SendRetrieveImageCommandSettings>()
.SingleInstance();
builder.RegisterType<SendRetrieveImageCommandActivity>();
builder.Register(context =>
{
var stateMachineActivityFactory = context.Resolve<IStateMachineActivityFactory>();
var machine = new ImageRetrievalStateMachine(stateMachineActivityFactory);
AutomatonymousStateUserType<ImageRetrievalStateMachine>.SaveAsString(machine);
return machine;
}).SingleInstance();
builder.RegisterType<ImageRetrievalStateBusInstance>()
.As<IServiceBusInstance>();
base.ConfigureLifetimeScope(builder);
}
public void Fetch()
{
var person = EntityCreator.Create<E.Person>();
var people = new InMemoryDbSet<E.Person> { person };
var context = new Mock<IEntityContext>(MockBehavior.Strict);
context.Setup(_ => _.People).Returns(people);
context.Setup(_ => _.Dispose());
var personViewFactory = new Mock<IObjectFactory<IPersonView>>(MockBehavior.Strict);
personViewFactory
.Setup(_ => _.FetchChild(It.Is<int>(__ => __ == person.Id)))
.Returns(Mock.Of<IPersonView>());
var container = new ContainerBuilder();
container.Register<IEntityContext>(_ => context.Object);
container.Register<IObjectFactory<IPersonView>>(_ => personViewFactory.Object);
using (container.Build().Bind(() => IoC.Container))
{
var actual = DataPortal.Fetch<PersonCollectionView>();
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count, "Count");
}
context.VerifyAll();
personViewFactory.VerifyAll();
}
/// <summary>
/// Override to add registrations to the container.
/// </summary>
/// <param name="builder">The builder through which components can be registered.</param>
/// <remarks>
/// Note that the ContainerBuilder parameter is not the same one
/// that the module is being registered by (i.e. it can have its own defaults).
/// </remarks>
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
// Register the global application objects
{
// Utilities
builder.Register(c => new ApplicationConstants())
.As<ApplicationConstants>();
builder.Register(c => new FileConstants(c.Resolve<ApplicationConstants>()))
.As<FileConstants>();
builder.Register(c => new XmlConfiguration(
ExecutorConfigurationKeys.ToCollection()
.Append(CommunicationConfigurationKeys.ToCollection())
.Append(DiagnosticsConfigurationKeys.ToCollection())
.ToList(),
ExecutorConstants.ConfigurationSectionApplicationSettings))
.As<IConfiguration>()
.SingleInstance();
RegisterLoggers(builder);
RegisterProfiler(builder);
RegisterDiagnostics(builder);
}
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterApiControllers(typeof(WebApiApplication).Assembly);
builder.RegisterControllers(typeof(WebApiApplication).Assembly);
builder.RegisterModule<AutofacWebTypesModule>();
builder.RegisterType<GroupService>().As<IGroupService>();
builder.RegisterType<UserService>().As<IUserService>();
builder.RegisterType<EventService>().As<IEventService>();
builder.RegisterType<CommentService>().As<ICommentService>();
builder.RegisterType<SearchService>().As<ISearchService>();
builder.Register(s => new UserRepository(ConnectionString)).As<IUserRepository>();
builder.Register(s => new GroupRepository(ConnectionString)).As<IGroupRepository>();
builder.Register(s => new EventRepository(ConnectionString)).As<IEventRepository>();
builder.Register(s => new CommentRepository(ConnectionString)).As<ICommentRepository>();
builder.Register(s => new SearchRepository(ConnectionString)).As<ISearchRepository>();
builder.RegisterType<RedisClient>().As<IRedisClient>()
.UsingConstructor(typeof(string), typeof(int))
.WithParameters(new List<Parameter>
{
new TypedParameter(typeof (string), "127.0.0.1"),
new TypedParameter(typeof (int), 6379)
});
}
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 async Task RegisterNewOrUpdateDetailsAsyncAndShouldReturnOne()
{
ContainerBuilder autoFacBuilder = new ContainerBuilder();
autoFacBuilder.Register(c =>
{
var iHaslContext = Substitute.For<IHaslContext>();
return iHaslContext;
}).InstancePerDependency();
autoFacBuilder.Register(c =>
{
var iEntityFacade = Substitute.For<ICareGiverFacade>();
iEntityFacade.GetDetails(Arg.Any<IHaslContext>(), Arg.Any<string>()).Returns((CareGiver)null);
iEntityFacade.AddNew(Arg.Any<IHaslContext>(), Arg.Any<CareGiver>()).Returns(1);
return iEntityFacade;
}).InstancePerDependency();
autoFacBuilder.RegisterType<CareGiverFacade>().As<ICareGiverManager>().InstancePerDependency();
IContainer iContainer = autoFacBuilder.Build();
var iCurdLogicManager = iContainer.Resolve<ICareGiverManager>();
var modifiedCount = await iCurdLogicManager.RegisterNewOrUpdateDetailsAsync(new Entities.CareGiver()
{
RegisteredUserId = 1,
Description = "Test Caregiver",
});
Assert.Equal<int>(1, modifiedCount);
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(c =>
{
var cc = c.Resolve<IComponentContext>();
var config = cc.Resolve<AppConfiguration>();
return new IwsClient(config.ApiUrl);
}).As<IIwsClient>().InstancePerRequest();
builder.Register(c =>
{
var cc = c.Resolve<IComponentContext>();
var config = cc.Resolve<AppConfiguration>();
return new OAuthClient(config.ApiUrl, config.ApiClientId, config.ApiSecret);
}).As<IOAuthClient>().SingleInstance();
builder.Register(c =>
{
var cc = c.Resolve<IComponentContext>();
var config = cc.Resolve<AppConfiguration>();
return new UserInfoClient(config.ApiUrl);
}).As<IUserInfoClient>().InstancePerRequest();
builder.RegisterType<ApiMediator>().As<IMediator>().InstancePerRequest();
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
builder
.RegisterType<WcfAppDomainInitializer>()
.AsImplementedInterfaces()
.SingleInstance();
builder
.RegisterType<WcfServer>()
.AsImplementedInterfaces()
.SingleInstance();
builder
.RegisterCmdLineFlag("nowcf", "Do not run the embedded WCF Server; running it is the default when no action parameter is specified", NoWcfKey);
builder
.Register(c => new AutofacServiceHostFactory())
.As<AutofacServiceHostFactory>()
.SingleInstance();
builder
.Register(c => new AutofacWebServiceHostFactory())
.As<AutofacWebServiceHostFactory>()
.SingleInstance();
}
protected override void Load(Autofac.ContainerBuilder builder)
{
builder.RegisterType <ServiceClientFactory>().As <IServiceClientFactory>().SingleInstance();
builder.RegisterInstance(new ZmqClient(new ZMQ.Context(), "tcp://localhost:8001", "tcp://localhost:8002"))
.As <IClient>().SingleInstance();
builder.Register <ICatalogService>(ctx => ctx.Resolve <IServiceClientFactory>().CreateServiceClient <ICatalogService>(15000));
builder.Register <IFooService>(ctx => ctx.Resolve <IServiceClientFactory>().CreateServiceClient <IFooService>(15000));
}
/// <summary>
/// 委托工厂注册
/// 【Register】+ 委托
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
protected override Autofac.ContainerBuilder RegisterFunc(Autofac.ContainerBuilder builder)
{
builder.Register(x => new StudentRepository())
.As <IStudentRepository>();
builder.Register(x => new StudentAppService(x.Resolve <IStudentRepository>())//指定参数
{
//TeacherRepository = x.Resolve<ITeacherRepository>()//拉姆达式属性注入（与属性注入不同，这里如果容器找不到解析会报异常，属性注入不会）
})
.As <IStudentAppService>();
return(builder);
}
private void RegisterMediatr(Autofac.ContainerBuilder builder)
{
builder.RegisterSource(new ContravariantRegistrationSource());
builder.RegisterAssemblyTypes(typeof(IMediator).GetTypeInfo().Assembly).AsImplementedInterfaces();
builder.Register <SingleInstanceFactory>(ctx =>
{
var c = ctx.Resolve <IComponentContext>();
return(t => c.Resolve(t));
});
builder.Register <MultiInstanceFactory>(ctx =>
{
var c = ctx.Resolve <IComponentContext>();
return(t => (IEnumerable <object>)c.Resolve(typeof(IEnumerable <>).MakeGenericType(t)));
});
}
protected override void Load(ATF.ContainerBuilder builder)
{
builder
.Register(context => new Nettolicious.Common.Logging.NLog.Logger(NLG.LogManager.GetCurrentClassLogger()))
.As <Nettolicious.Common.Logging.ILogger>()
.SingleInstance();
}
/// <summary>
/// 属性注入方法1
/// 拉姆达
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
protected override Autofac.ContainerBuilder RegisterFunc(Autofac.ContainerBuilder builder)
{
builder.Register(x => new TeacherRepository
{
TestStr = "test"
})
.AsImplementedInterfaces();
builder.Register(x => new TeacherAppService())
.OnActivated(e => e.Instance.TeacherRepository = e.Context.Resolve <ITeacherRepository>())
.AsImplementedInterfaces();
return(builder);
//拉姆达式属性注入（与属性注入不同，如果容器找不到，Resolve解析会报异常，属性注入不会）
}
public static IContainer BuildOne()
{
Dictionary <string, string> pepe = new Dictionary <string, string>();
string pepito = pepe.First().Key;
IContainer container = null;
try
{
Autofac.ContainerBuilder containerBuilder = new Autofac.ContainerBuilder();
containerBuilder.RegisterType <Robot>().As <IMachine>();
containerBuilder.Register((name, value) =>
{
IMachine machine;
if (value.Named <string>("function").Trim().ToLower() == "transport") /// It should be an enum type
{
machine = new Drone();
}
else
{
machine = new Robot();
}
return(machine);
}).As <IMachine>();
//builder.RegisterType<Drone>()
// .As<IMachine>()
// .As<IGun>()
// .IfNotRegistered(typeof(IMachine));
container = containerBuilder.Build();
}
catch { throw new Exception("Container Exception"); }
return(container);
}
IContainer InitializeIoC()
{
Autofac.ContainerBuilder builder = new Autofac.ContainerBuilder();
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
builder.RegisterAssemblyTypes(assemblies)
.Where(t => !t.Name.StartsWith("System"))
.AsImplementedInterfaces();
builder.Register(context => LogManager.GetLogger("BackerUpper")).As <ILogger>();
builder.Register(context =>
{
var config = ConfigurationManager.GetSection("backerUpper");
return(config as BackerUpper.Configuration.Configuration);
}).As <BackerUpper.Configuration.IConfiguration>();
return(builder.Build());
}
public static void Register(Action <ContainerBuilder> action)
{
var builder = new Autofac.ContainerBuilder();
builder.Register(x => SettingFactory.Create <PackSetting>()).As <PackSetting>().InstancePerLifetimeScope();
builder.RegisterType <GitCommandHelper>().As <IGitCommandHelper>().InstancePerLifetimeScope();
builder.RegisterType <PathService>().As <IPathService>().SingleInstance();
builder.RegisterType <GitPackEngine>().As <IGitPackEngine>().InstancePerLifetimeScope();
builder.RegisterType <FileAnalysisFactory>().As <IFileAnalysisFactory>().InstancePerLifetimeScope();
builder.RegisterType <ProjectFilePreparer>().As <IChangedFilePreparer>().InstancePerLifetimeScope();
builder.RegisterType <ScreenLogger>().As <ILogger>().SingleInstance();
builder.RegisterType <VisualStudioProjectCompiler>().As <IVisualStudioProjectCompiler>().InstancePerLifetimeScope();
//builder.RegisterType<FakeCompilier>().As<IVisualStudioProjectCompiler>().InstancePerLifetimeScope();
builder.RegisterType <FilePackService>().As <IFilePackService>().InstancePerLifetimeScope();
builder.RegisterType <BuildServiceFactory>().As <IBuildServiceFactory>().InstancePerLifetimeScope();
builder.RegisterType <ProjectParserServiceFactory>().As <IProjectParserServiceFactory>().InstancePerLifetimeScope();
builder.RegisterType <VisualStudioProjectFinder>().As <IProjectFinder>().InstancePerLifetimeScope();
builder.RegisterType <ProjectFilter>().As <IProjectFilter>().SingleInstance();
builder.RegisterType <PackageCompressService>().As <IPackageCompressService>().InstancePerLifetimeScope();
builder.RegisterType <ProjectDiffer>().As <IProjectDiffer>().InstancePerLifetimeScope();
builder.RegisterType <VisualStudioSolutionFinder>().As <ISolutionFinder>().InstancePerLifetimeScope();
builder.RegisterType <VisualStudioSolutionParser>().As <ISolutionParser>().InstancePerLifetimeScope();
builder.RegisterType <NugetPackageManager>().As <INugetPackageManager>().InstancePerLifetimeScope();
action(builder);
IContainer iocContainer = builder.Build();
ContainerManager.SetContainer(iocContainer);
}
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>();
}
}
protected override void Load(Autofac.ContainerBuilder builder)
{
base.Load(builder);
builder.Register <MailProblemReporter>(c => new MailProblemReporter(c.Resolve <IMailSender>()))
.As <IProblemReporter>()
.SingleInstance();
}
protected override void Load(Autofac.ContainerBuilder builder)
{
base.Load(builder);
builder.Register <FogBugzProblemReporter>(c => new FogBugzProblemReporter())
.As <IProblemReporter>()
.SingleInstance();
}
protected override void Load(AF.ContainerBuilder builder)
{
base.Load(builder);
// Database Providers
builder
.RegisterType <DatabaseProviderFactory>()
.As <IDatabaseProviderFactory>()
.SingleInstance();
builder
.RegisterType <SqlServerDatabaseProvider>()
.Named <IDatabaseProvider>(DbProviders.SqlServer.ToString());
builder
.RegisterType <SQLiteDatabaseProvider>()
.Named <IDatabaseProvider>(DbProviders.SQLite.ToString());
builder
.Register(c =>
{
var factory = c.Resolve <IDatabaseProviderFactory>();
var config = c.Resolve <IPersistenceConfigs>();
return(factory.Create(config.DatabaseProvider));
})
.As <IDatabaseProvider>()
.InstancePerLifetimeScope();
builder
.Register(c =>
{
return(new NHPersistenceContextFactory(
c.Resolve <IPersistenceConfigs>(),
c.Resolve <IDatabaseProviderFactory>(),
typeof(UserMapping).Assembly));
})
.As <IPersistenceContextFactory>()
.As <IPersistenceMetaContextFactory>()
.SingleInstance();
builder
.RegisterType <PersistenceUnitOfWorkFactory>()
.AsSelf()
.As <IPersistenceUnitOfWorkFactory>()
.SingleInstance();
}
protected override void Load(Autofac.ContainerBuilder builder)
{
base.Load(builder);
builder
.Register <DefaultCredentialsResolver>(c => new DefaultCredentialsResolver())
.As <ICredentialsResolver>()
.SingleInstance();
}
private ContainerBuilder InitContainerBuilder()
{
var builder = new Autofac.ContainerBuilder();
builder.Register <ChorusNotesDisplaySettings>(c => DisplaySettings);
ChorusUIComponentsInjector.Inject(builder, _dataFolderPath);
return(builder);
}
private void SetIoc()
{
var containerBuilder = new Autofac.ContainerBuilder();
containerBuilder.Register(c => AndroidDevice.CurrentDevice).As <IDevice>();
containerBuilder.RegisterType <MainViewModel>().AsSelf();
Resolver.SetResolver(new AutofacResolver(containerBuilder.Build()));
}
protected override void Register(Autofac.ContainerBuilder builder)
{
_descriptor = new ShellDescriptor {
};
_testViewEngine = new TestViewEngine();
_testVirtualPathProvider = new TestVirtualPathProvider {
TestViewEngine = _testViewEngine
};
builder.Register(ctx => _descriptor);
builder.RegisterType <StylesheetBindingStrategy>().As <IShapeTableProvider>();
builder.RegisterInstance(_testViewEngine).As <IShapeTemplateViewEngine>();
builder.RegisterInstance(_testVirtualPathProvider).As <IVirtualPathProvider>();
var extensionManager = new Mock <IExtensionManager>();
builder.Register(ctx => extensionManager);
builder.Register(ctx => extensionManager.Object);
}
private void RegisterServices()
{
var containerBuilder = new Autofac.ContainerBuilder();
containerBuilder.RegisterType <SqliteDataStore <Entities.Transaction> >().As <IDataStore <Entities.Transaction> >();
containerBuilder.Register <AutoMapper.IMapper>(cc => _automapperCfg.CreateMapper());
_container = containerBuilder.Build();
DependencyResolver.ResolveUsing((t, ro) => _container.IsRegistered(t) ? _container.Resolve(t) : null);
System.Threading.Tasks.Task.Run(() => DependencyService.Resolve <IDataStore <Entities.Transaction> >().CreateTablesAsync());
}
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>();
}
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();
}
public static Autofac.ContainerBuilder AddScriptingServices(this Autofac.ContainerBuilder services)
{
services.Register <ScriptEngine>(x => IronPython.Hosting.Python.CreateEngine())
.InstancePerDependency().Keyed <ScriptEngine>("Python");
//services.Register<ScriptEngine>(x => IronRuby.Ruby.CreateEngine())
// .InstancePerDependency().Keyed<ScriptEngine>("Ruby");
services.RegisterType <ScriptRunner>().As <IScriptRunner>().InstancePerDependency();
return(services);
}
public void Register(Autofac.ContainerBuilder builder, Nop.Core.Infrastructure.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();
//每次依赖都使用一个新的数据库对象
builder.Register <IDbContext>(c => new NopObjectContext()).InstancePerDependency();
//注册工作单元
builder.RegisterType <UnitOfWork>().As <IUnitOfWork>().InstancePerDependency();
//注册泛型仓储
builder.RegisterGeneric(typeof(EfRepository <>)).As(typeof(IRepository <>)).InstancePerLifetimeScope();
//注册服务
builder.RegisterType <Nop.Services.Users.UserService>().As <Nop.Services.Users.IUserService>().InstancePerLifetimeScope();
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
.Where(t => !t.IsAbstract && typeof(ApiController).IsAssignableFrom(t))
.InstancePerMatchingLifetimeScope();
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly()).AsImplementedInterfaces();
}
protected override void Register(Autofac.ContainerBuilder builder)
{
_defaultShapeTable = new ShapeTable {
Descriptors = new Dictionary <string, ShapeDescriptor>(StringComparer.OrdinalIgnoreCase),
Bindings = new Dictionary <string, ShapeBinding>(StringComparer.OrdinalIgnoreCase)
};
_workContext = new TestWorkContext {
CurrentTheme = new ExtensionDescriptor {
Id = "Hello"
}
};
builder.RegisterType <DefaultDisplayManager>().As <IDisplayManager>();
builder.RegisterType <TestShapeTableManager>().As <IShapeTableManager>();
builder.RegisterType <ShapeTableLocator>().As <IShapeTableLocator>();
builder.RegisterType <TestWorkContextAccessor>().As <IWorkContextAccessor>();
builder.RegisterType <TestDisplayEvents>().As <IShapeDisplayEvents>()
.As <TestDisplayEvents>()
.InstancePerLifetimeScope();
builder.Register(ctx => _defaultShapeTable);
builder.Register(ctx => _workContext);
}
public override void Register(Autofac.ContainerBuilder builder)
{
builder.RegisterModule(new hems.HighTail.Logging.LogInjectionModule());
hems.HighTail.Logging.LogInjectionModule.SetLevel("Log", "Info");
builder.RegisterType <ApiHelper>();
builder.RegisterType <Storage>().As <IStorage>();
builder.RegisterType <Share>().As <IShare>();
builder.RegisterType <Files>().As <IFiles>();
builder.RegisterType <YouSendItAPI>().As <IYouSendItAPI>()
.WithParameter("apiEndpoint", ConfigurationManager.AppSettings["ApiEndPoint_Sandbox"])
.WithParameter("apiKey", ConfigurationManager.AppSettings["Api_Key_Sandbox"]);
builder.Register((c) => {
return(c.Resolve <ApiHelper>());
}).As <IApiHelper>();
}
protected void Application_Start()
{
var builder = new Autofac.ContainerBuilder();
builder.RegisterControllers(typeof(HomeController).Assembly);
builder.Register(_ => LogManager.GetLogger("ControllersLogger")).As <ILogger>();
DependencyResolver.SetResolver(new AutofacDependencyResolver(builder.Build()));
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
logger.Info("Application_Start");
}
protected override void Load(Autofac.ContainerBuilder builder)
{
base.Load(builder);
builder
.Register <BasicAuthCredentialsResolver>(c => new BasicAuthCredentialsResolver(c.Resolve <IViewModelFactory>(), c.Resolve <Func <BaseMemoryContext> >()))
.As <BasicAuthCredentialsResolver>() // for local use
.As <ICredentialsResolver>() // for publication
.SingleInstance();
// since the user has entered credentials, now we also have a different Identity
builder
.RegisterType <BasicAuthIdentityResolver>()
.As <IIdentityResolver>()
.InstancePerLifetimeScope();
}
protected override void Load(Autofac.ContainerBuilder builder)
{
// Register MVC controllers using assembly scanning.
builder.RegisterControllers(System.Reflection.Assembly.GetExecutingAssembly());
// Dependency injection module that registers abstractions for common web application properties.
// Ref: http://autofac.org/apidoc/html/DA6737B.htm
builder.RegisterModule(new AutofacWebTypesModule());
builder.RegisterFilterProvider();
//Injecting the Redis client service
builder.RegisterType <NewtonsoftSerializer>().As <ISerializer>().SingleInstance();
builder.RegisterType <StackExchangeRedisCacheClient>().As <ICacheClient>().SingleInstance();
builder.Register(c => CacheProviderManager.Default).As <ICacheProvider>().SingleInstance();
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
global::Xamarin.Forms.Forms.Init(this, bundle);
var containerBuilder = new Autofac.ContainerBuilder();
containerBuilder.Register(c => this).As <Context>();
containerBuilder.RegisterType <MediaPicker> ().As <IMediaPicker> ();
containerBuilder.RegisterType <TesseractApi> ().As <ITesseractApi> ();
Resolver.SetResolver(new AutofacResolver(containerBuilder.Build()));
LoadApplication(new App());
}
public BaseSetup()
{
var container = new Autofac.ContainerBuilder();
container.RegisterModule <ApiModules>();
container.RegisterType <MdmServiceConfiguration>().AsImplementedInterfaces();
container.Register(c => new MdmServiceConfiguration(
"TestEffective01",
"Dlt@3618",
"http://192.168.6.13",
"748681ca3646ccc7c4facb7360a0e3baa0894cb5",
"http://localhost:8015")).AsImplementedInterfaces();
var build = container.Build();
Container = build;
}
protected override void SetupBuilder(Autofac.ContainerBuilder builder)
{
base.SetupBuilder(builder);
builder.RegisterModule(new Zetbox.API.ApiModule());
builder.RegisterModule(new Zetbox.API.Server.ServerApiModule());
builder
.RegisterType <MetaDataResolverMock>()
.As <IMetaDataResolver>()
.InstancePerDependency();
builder.Register(c => new ZetboxContextMock(c.Resolve <IMetaDataResolver>(), null, c.Resolve <ZetboxConfig>(), c.Resolve <Func <IFrozenContext> >(), c.Resolve <InterfaceType.Factory>()))
.As <IZetboxContext>()
.As <IFrozenContext>()
.As <IReadOnlyZetboxContext>()
.InstancePerDependency();
}
