/// <summary> /// Adds the IOC Container to the specified. /// <see cref="Microsoft.Extensions.DependencyInjection.IServiceCollection"></see> /// </summary> /// <param name="services"></param> /// <returns></returns> public static IServiceProvider AddIocContainer(this IServiceCollection services) { var containerBuilder = new IocConfiguration(); var container = containerBuilder.BuildContainer(services); return(container.Resolve <IServiceProvider>()); }
protected override void OnStartup(StartupEventArgs e) { var container = IocConfiguration.GetConteiner(); var locator = new UnityServiceLocator(container); ServiceLocator.SetLocatorProvider(() => locator); }
public static ContainerBuilder RegisterAll ( Dictionary <Type, Type> repositoryKeyTypes, Type repositoryKeyTypeDefault, string connectionStringKeyBedrock, Assembly bootstrapAssembly, Assembly[] serviceAssemblies, Assembly[] domainAssemblies, Assembly webAssembly, CoreConfiguration.BedrockConfiguration bedrockConfiguration, IocConfiguration iocConfiguration, DependentType dependentType ) { return(RegisterBase ( repositoryKeyTypes, repositoryKeyTypeDefault, connectionStringKeyBedrock, bootstrapAssembly, serviceAssemblies, domainAssemblies, webAssembly, bedrockConfiguration, iocConfiguration, dependentType ) .RegisterSecurity(iocConfiguration)); }
public IocContainer(IocConfiguration configuration) { _iocConfig = configuration; Services = new ServiceCollection(); RegisterTypes(); }
/// <summary> /// Create IoC Container /// </summary> /// <param name="config">IocConfiguration Implements Object</param> public static void Initialize(IocConfiguration config) { if (_kernel == null) { _kernel = new StandardKernel(config); } }
/// <inheritdoc /> /// <summary> /// Overridable method to execute when All resolvers have been initialized but resolution is not frozen so they can be modified in this method /// </summary> /// <param name="umbracoApplication"></param> /// <param name="applicationContext"></param> protected override void ApplicationStarting( UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext) { LogHelper.Info(GetType(), "ApplicationStarting"); IocConfiguration.Setup(); base.ApplicationStarting(umbracoApplication, applicationContext); //// add our 404 resolver ContentFinderResolver.Current.InsertTypeBefore <ContentFinderByNiceUrl, PageNotFoundContentFinder>(); // Remove ContentFinderByNiceUrl ContentFinderResolver.Current.RemoveType <ContentFinderByNiceUrl>(); RazorViewEngine razorEngine = ViewEngines.Engines.OfType <RazorViewEngine>().FirstOrDefault(); if (razorEngine != null) { razorEngine.PartialViewLocationFormats = razorEngine.PartialViewLocationFormats.Concat(new[] { "~/Views/Partials/Spectrum/Payments/{0}.cshtml", "~/Views/Partials/Spectrum/Appointments/{0}.cshtml" }).ToArray(); } }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); IocConfiguration.Configure(); }
public override bool FinishedLaunching(UIApplication app, NSDictionary options) { global::Xamarin.Forms.Forms.Init(); IocConfiguration.Configure(); LoadApplication(new App()); return(base.FinishedLaunching(app, options)); }
public static ContainerBuilder Bootstrap(DependentType dependentType, string connectionStringKeyBedrock, CoreConfiguration.BedrockConfiguration bedrockConfiguration) { DependentType = dependentType; ConnectionStringKeyBedrock = connectionStringKeyBedrock; BedrockConfiguration = bedrockConfiguration; IocConfiguration = IocConfiguration.Current; return(CreateContainerBuilder()); }
static EmulatorAgent() { var builder = IocConfiguration.GetContainerBuilder(); //Ensure that core Ioc services can run with the emulator. builder.UseEmulator(); _container = builder.Build(); }
public MainWindow() { InitializeComponent(); _bankingService = IocConfiguration.Initialize().Resolve <IBankingService>(); _tblUpdate = IocConfiguration.Initialize().Resolve <IUpdateDbTables>(); _transactionService = IocConfiguration.Initialize().Resolve <ITransactionService>(); _objectConversions = IocConfiguration.Initialize().Resolve <ObjectConversions>(); _initiateDataUpdate = IocConfiguration.Initialize().Resolve <InitiateDataUpdate>(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); ConfigureVersioningAndSwagger(services); ConfigureJsonServices(services); ConfigureLogging(services); ConfigureOtherServices(services); ConfigureDb(services); IocConfiguration.Configure(services); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); RouteConfig.RegisterRoutes(RouteTable.Routes); AutoMapperMVCConfig.RegisterMappings(); AutoMapperBusinessConfig.RegisterMappings(); IocConfiguration.ConfigureDependencyInjection(); }
protected void Application_Start() { //Para utilizar IOC (Inversion Of Control) y DI (Dependency Injection) con Autofac IocConfiguration.Configure(); AreaRegistration.RegisterAllAreas(); GlobalConfiguration.Configure(WebApiConfig.Register); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); }
/// <summary> /// Registers common application dependencies /// </summary> /// <param name="bootstrapAssembly">Used to scan for types</param> /// <param name="serviceAssemblies">Used to scan for types</param> /// <param name="domainAssemblies">Used to scan for types</param> /// <param name="dependentType">Type of application</param> /// <param name="bedrockConfiguration">If NetCoreApp application, must be passed in, or registration will throw. If Framework application, will be built here, so no need to pass in.</param> /// <returns>Current builder</returns> public static ContainerBuilder RegisterAll ( Assembly bootstrapAssembly = null, Assembly[] serviceAssemblies = null, Assembly[] domainAssemblies = null, DependentType dependentType = DependentType.Default, CoreConfiguration.BedrockConfiguration bedrockConfiguration = null, IocConfiguration iocConfiguration = null ) { return(RegisterAll(CreateContainerBuilder(bootstrapAssembly), bootstrapAssembly, serviceAssemblies, domainAssemblies, dependentType, bedrockConfiguration, iocConfiguration)); }
protected override void OnCreate(Bundle bundle) { TabLayoutResource = Resource.Layout.Tabbar; ToolbarResource = Resource.Layout.Toolbar; IocConfiguration.Configure(); base.OnCreate(bundle); Forms.Init(this, bundle); LoadApplication(new App()); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { var connString = Configuration.GetConnectionString("DefaultConnection"); services.AddDbContext <StepCoreContext>(option => option.UseSqlServer(connString)); IocConfiguration.Init(Configuration, services); AuthConfiguration.Init(Configuration, services); services.AddControllers(); services.AddCors(opt => { opt.AddPolicy("AllowMyOrigin", builder => builder.AllowAnyHeader().AllowAnyOrigin().AllowAnyMethod()); }); }
protected override void OnStartup(StartupEventArgs e) { base.OnStartup(e); //Register the IOC container IocConfiguration.RegisterIoc(); MainWindow main = new MainWindow(); ApplicationViewModel context = new ApplicationViewModel(); main.DataContext = context; main.Show(); }
public static ContainerBuilder RegisterHasher(this ContainerBuilder builder, IocConfiguration iocConfiguration) { if (!iocConfiguration.IsRegisterHasher) { return(builder); } builder .RegisterType <Hasher>() .As <IHasher>() .SingleInstance(); return(builder); }
/// <summary> /// Registers common application dependencies /// </summary> /// <param name="builder">Current builder</param> /// <param name="bootstrapAssembly">Used to scan for types</param> /// <param name="serviceAssemblies">Used to scan for types</param> /// <param name="domainAssemblies">Used to scan for types</param> /// <param name="dependentType">Type of application</param> /// <param name="bedrockConfiguration">If NetCoreApp application, must be passed in, or registration will throw. If Framework application, will be built here, so no need to pass in.</param> /// <returns>Current builder</returns> public static ContainerBuilder RegisterAll ( ContainerBuilder builder, Assembly bootstrapAssembly = null, Assembly[] serviceAssemblies = null, Assembly[] domainAssemblies = null, DependentType dependentType = DependentType.Default, CoreConfiguration.BedrockConfiguration bedrockConfiguration = null, IocConfiguration iocConfiguration = null ) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if ((dependentType == DependentType.AspNetCore || dependentType == DependentType.NetCoreApp) && bedrockConfiguration == null) { throw new ArgumentNullException(nameof(bedrockConfiguration)); } var thisAssembly = Assembly.GetAssembly(typeof(AutofacFactory)); var autoMapperAssembly = Assembly.GetAssembly(typeof(AutoMapperConfiguration)); if (iocConfiguration == null) { iocConfiguration = IocConfiguration.Current; } return(builder .RegisterLoggerNLog(iocConfiguration) .RegisterMapperAutoMapper(iocConfiguration, bootstrapAssembly, thisAssembly, autoMapperAssembly) .RegisterMapperHelper(iocConfiguration) .RegisterSession(dependentType, iocConfiguration) .RegisterOrmHelper(iocConfiguration) .RegisterCacheProvider(bedrockConfiguration, iocConfiguration) .RegisterQueueProvider(bedrockConfiguration, iocConfiguration) .RegisterSerializationProvider(iocConfiguration) .RegisterHasher(iocConfiguration) .RegisterServices(serviceAssemblies, iocConfiguration) .RegisterValidationConfigurators(domainAssemblies, iocConfiguration) .RegisterEventDispatcher(dependentType, iocConfiguration) .RegisterDomainEventHandlers(domainAssemblies, iocConfiguration) .RegisterWebApiClient(iocConfiguration)); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { var businessAssembly = typeof(HashDecoderAPI.Business.MappingProfile).Assembly; var contractsAssembly = typeof(HashDecoderAPI.Contracts.Marker).Assembly; // services.AddDbContext<HashDecoderAPIContext>(options => options.UseSqlServer(Configuration["ConnectionStrings:Default"])); services.AddAutoMapper(businessAssembly, contractsAssembly); services.AddMediatR(businessAssembly, contractsAssembly); services .AddMvc() .AddControllersAsServices() .SetCompatibilityVersion(CompatibilityVersion.Version_2_2); SwaggerConfiguration.ConfigureServices(services, Configuration); services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>(); IocConfiguration.RegisterAllDependencies(services); AuthConfiguration.ConfigureServices(services, Environment, Configuration); }
public static ContainerBuilder RegisterBase ( Dictionary <Type, Type> repositoryKeyTypes, Type repositoryKeyTypeDefault, string connectionStringKeyTemplate, Assembly bootstrapAssembly, Assembly[] serviceAssemblies, Assembly[] domainAssemblies, Assembly webAssembly, CoreConfiguration.BedrockConfiguration bedrockConfiguration, IocConfiguration iocConfiguration, DependentType dependentType ) { return(SharedIoC .AutofacFactory .RegisterAll(bootstrapAssembly, serviceAssemblies, domainAssemblies, dependentType, bedrockConfiguration) .RegisterDataContextTemplate(connectionStringKeyTemplate, bedrockConfiguration) .RegisterRepositoriesTemplate(repositoryKeyTypes, repositoryKeyTypeDefault, iocConfiguration) .RegisterApplicationContextTemplate()); }
private IDependencyResolver ConfigureIocResolver() { // Setup configuration for IOC container here var config = new IocConfiguration(); config.CacheType = GetCacheManagerType(); config.RegexStringList = GetLoggingRegularExpressionList(); var iocContainer = new IocContainer(config); var controllerTypes = Assembly.GetExecutingAssembly().GetExportedTypes() .Where(t => !t.IsAbstract && !t.IsGenericTypeDefinition) .Where(t => typeof(ApiController).IsAssignableFrom(t) || t.Name.EndsWith("Controller", StringComparison.OrdinalIgnoreCase)); foreach (var type in controllerTypes) { iocContainer.Services.AddTransient(type); } var iocResolver = new DefaultDependencyResolver(iocContainer.BuildServiceProvider()); return(iocResolver); }
public static ContainerBuilder RegisterEventDispatcher(this ContainerBuilder builder, DependentType dependentType, IocConfiguration iocConfiguration) { if (!iocConfiguration.IsRegisterEventDispatcher) { return(builder); } var registration = builder .RegisterType <DomainEventDispatcher>() .As <IDomainEventDispatcher>(); return(builder); }
public static ContainerBuilder RegisterDomainEventHandlers(this ContainerBuilder builder, SystemReflection.Assembly[] domainAssemblies, IocConfiguration iocConfiguration) { if (!iocConfiguration.IsRegisterDomainEventHandlers) { return(builder); } if (domainAssemblies == null || !domainAssemblies.Any()) { return(builder); } domainAssemblies.Each(da => { builder .RegisterAssemblyTypes(da) .AsClosedTypesOf(typeof(IDomainEventHandler <>)); }); return(builder); }
public static ContainerBuilder RegisterWebApiClient(this ContainerBuilder builder, IocConfiguration iocConfiguration) { if (!iocConfiguration.IsRegisterWebApiClient) { return(builder); } builder .RegisterType <WebApiClient>() .As <IWebApiClient>() .SingleInstance(); return(builder); }
public static ContainerBuilder RegisterResourceAuthorizationManager(this ContainerBuilder builder, IocConfiguration iocConfiguration) { if (!iocConfiguration.IsRegisterResourceAuthorizationManager) { return(builder); } builder .RegisterType <BedrockResourceAuthorizationManager>() .As <IResourceAuthorizationManager>() .SingleInstance(); return(builder); }
public static ContainerBuilder RegisterMapperAutoMapper(this ContainerBuilder builder, IocConfiguration iocConfiguration, params SystemReflection.Assembly[] assemblies) { if (!iocConfiguration.IsRegisterMapper) { return(builder); } MapperAutoMapper.AutoMapperConfiguration.Configure(assemblies); builder .RegisterType <MapperAutoMapper.MapperAutoMapper>() .As <IMapperAutoMapper>() .UsingConstructor() .SingleInstance(); builder .RegisterType <MapperAutoMapper.Mapper>() .As <IMapper>() .UsingConstructor(typeof(IMapperAutoMapper)) .SingleInstance(); return(builder); }
public InitiateDataUpdate() { _dataMapper = IocConfiguration.Initialize().Resolve <IDataMapper>(); _tblUpdate = IocConfiguration.Initialize().Resolve <IUpdateDbTables>(); }
private void RegisterDependencies(ISettings settings) { IocConfiguration.Initialize(Container, settings); }