/// <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);
}
