// This method gets called by the runtime. Use this method to add services to the container. // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940 public void ConfigureServices(IServiceCollection services) { services.AddDbContext <FinanceDbContext>(options => options.UseInMemoryDatabase("FinanceDb")); services.AddRazorPages(); services.AddServerSideBlazor(); services = DependencyInjectionRegistration.Register(services); }
public void RegisterType(IServiceCollection serviceCollection, Type type) { if (!type.IsInterface) { if (type.IsClass && !type.IsAbstract) { // Filter attributes to have only attributes for arbitrary environments and attributes fitting to the current environment. var isEnvironmentCorrect = type.EvaluateDerivedCustomAttributePredicate <InjectionEnumRestrictionAttribute>(era => era.ValidEnumValues.Any(vev => _enumRestrictions.Any(ev => Equals(ev, vev))), trueIfEmpty: true); var registrationAttributes = type.GetCustomDerivedAttribute <InjectionRegistrationAttribute>() .OrderByDescending(i => i.RegisteredInterfaces.Count()) .ToList(); if (registrationAttributes.Any() && isEnvironmentCorrect) { var injectInListAttributes = type.GetSingleCustomAttribute <InjectInListAttribute>(); var alreadyRegisteredTypes = new HashSet <Type>(); foreach (var registrationAttribute in registrationAttributes) { IList <Type> interfaceTypes = registrationAttribute.RegisteredInterfaces; if (interfaceTypes.Any()) { var repeatedlyRegisteredTypes = interfaceTypes.Where(i => alreadyRegisteredTypes.Contains(i)).ToList(); if (repeatedlyRegisteredTypes.Any()) { throw new InjectionRegistrationException(repeatedlyRegisteredTypes.First(), type, $"Reflected interfaces [{string.Join( ", ", repeatedlyRegisteredTypes.Select( i => i.FullName ) )}] of {type.FullName} cannot be registered, since they were already registered for the same type with another attribute."); } // if ( !registrationAttribute.RegisteredInterfaces.Contains( type ) ) { // interfaceTypes = new Type[ registrationAttribute.RegisteredInterfaces.Count() + 1 ]; // interfaceTypes[ 0 ] = type; // registrationAttribute.RegisteredInterfaces.CopyTo( interfaceTypes, 1 ); // } else { // interfaceTypes = registrationAttribute.RegisteredInterfaces; // } } else { interfaceTypes = type.GetInterfaces().Where(i => !alreadyRegisteredTypes.Contains(i)).ToList(); if (!interfaceTypes.Contains(type)) { interfaceTypes.Insert(0, type); } interfaceTypes = interfaceTypes.Where(i => !alreadyRegisteredTypes.Contains(i)).ToList(); } var explicitOverriddenTypes = new HashSet <Type>(type.GetCustomAttribute <InjectionExplicitOverrideAttribute>().SelectMany(a => a.OverriddenTypes)); DependencyInjectionRegistration firstRegistration = null; foreach (var interfaceType in interfaceTypes) { CheckInterfaceType(interfaceType, type); // Selects the type to which the interface is mapped currently var existingRegistration = _registrations.SingleOrDefault(i => i.RegisteredInterface == interfaceType); if (existingRegistration != null && !type.IsSubclassOf(existingRegistration.RegisteredToType) && !explicitOverriddenTypes.Contains(existingRegistration.RegisteredToType)) { // Check whether this type was overridden explicitly var isExplicitlyOverridden = existingRegistration.RegisteredToType.EvaluateCustomAttributePredicate <InjectionExplicitOverrideAttribute>(eoa => eoa.OverriddenTypes.Any(t => t.Equals(type))); if (existingRegistration.RegisteredToType != type && !existingRegistration.RegisteredToType.IsSubclassOf(type) && !isExplicitlyOverridden) { // Only registrations of inherited types may be overwritten. An alternative branch to an already registered type may not be registered. throw new InjectionRegistrationException(interfaceType, type, $"Reflected interface {interfaceType.FullName} of {type.FullName} cannot be registered, since it is already registered to {existingRegistration.RegisteredToType.FullName}, which is not a superclass."); } if (firstRegistration == null) { firstRegistration = existingRegistration; } } else { var registration = new DependencyInjectionRegistration { RegisteredInterface = interfaceType, RegisteredToType = type, UsedOtherRegistration = firstRegistration }; _registrations.Add(registration); switch (registrationAttribute) { case InjectAsGlobalSingletonAttribute _: registration.Lifetime = ServiceLifetime.Singleton; if (firstRegistration == null) { serviceCollection.AddSingleton(interfaceType, type); } else { serviceCollection.AddSingleton(interfaceType, sp => sp.GetService(firstRegistration.RegisteredInterface)); } break; case InjectAsRequestSingletonAttribute _: registration.Lifetime = ServiceLifetime.Scoped; if (firstRegistration == null) { serviceCollection.AddScoped(interfaceType, type); } else { serviceCollection.AddScoped(interfaceType, sp => sp.GetService(firstRegistration.RegisteredInterface)); } break; case InjectAsNewInstanceAttribute _: registration.Lifetime = ServiceLifetime.Transient; if (firstRegistration == null) { serviceCollection.AddTransient(interfaceType, type); } else { serviceCollection.AddTransient(interfaceType, sp => sp.GetService(firstRegistration.RegisteredInterface)); } break; default: // An implementation of IInjcetionScopeAttribute was given, but is not supported. throw new InjectionRegistrationException(interfaceType, type, $"Reflected interface {interfaceType.FullName} of {type.FullName} cannot be registered, since InjectionRegistrationAttribute was invalid."); } if (existingRegistration != null && (type.IsSubclassOf(existingRegistration.RegisteredToType) || explicitOverriddenTypes.Contains(existingRegistration.RegisteredToType))) { var existingRegistrationChildren = existingRegistration.UsedByOtherRegistrations.ToList(); foreach (var existingRegistrationChild in existingRegistrationChildren) { CheckInterfaceType(existingRegistrationChild.RegisteredInterface, type); existingRegistrationChild.RegisteredToType = type; existingRegistrationChild.UsedOtherRegistration = registration; registration.UsedByOtherRegistrations.Add(existingRegistrationChild); } _registrations.Remove(existingRegistration); } if (firstRegistration == null) { firstRegistration = registration; } else { firstRegistration.UsedByOtherRegistrations.Add(registration); } } } if (injectInListAttributes.Count == 1) { var injectInListAttribute = injectInListAttributes.First(); var listInterfaceTypes = injectInListAttribute.RegisteredInterfaces; if (!serviceCollection.Any(reg => reg.ServiceType == typeof(ListInjectionRegistrationManager))) { serviceCollection.AddSingleton(_listInjectionRegistrationManager); } foreach (var interfaceType in listInterfaceTypes) { CheckInterfaceType(interfaceType, type); _listInjectionRegistrationManager.RegisterTypeForListInterfaceType(type, interfaceType, injectInListAttribute.RemoveSubtypesFromList); var listInjectionType = typeof(IEnumerable <>).MakeGenericType(interfaceType); if (!serviceCollection.Any(reg => reg.ServiceType == listInjectionType)) { var listInjectionProxyType = typeof(ListInjectionProxy <>).MakeGenericType(interfaceType); serviceCollection.AddTransient(listInjectionType, listInjectionProxyType); } } } } } } } }
public static IHostBuilder CreateHostBuilder() { var hzConfiguration = new HazelcastConfig(); var emailSettings = new EmailSettings(); return(new HostBuilder() .ConfigureAppConfiguration((hostContext, configurationBuilder) => { var configurationRoot = configurationBuilder .AddJsonFile("appsettings.json") .AddEnvironmentVariables() .Build(); configurationRoot.Bind(nameof(HazelcastConfig), hzConfiguration); configurationRoot.Bind(nameof(EmailSettings), emailSettings); }) .ConfigureLogging(loggingBuilder => { loggingBuilder.ClearProviders(); loggingBuilder.UseLog4Net(new FileInfo("log4net.config")); }) .ConfigureSimpleInjector() .ConfigureContainer <Container>((hostBuilderContext, container) => { container.RegisterSingleton(() => hzConfiguration); // Register IMessagingClientFactory container.RegisterSingleton <IMessagingClientFactory, HazelcastMessagingClientFactory>(); // Register IMessagingClient container.RegisterSingleton(() => { var config = container.GetInstance <IConfiguration>(); var factory = container.GetInstance <IMessagingClientFactory>(); return factory.CreateClient(nameof(HazelcastConfig), config); }); // Register IMessagePublisher container.RegisterSingleton <IMessagePublisher>(container.GetInstance <IMessagingClient>); // Register IMessageSubscriber container.RegisterSingleton <IMessageSubscriber>(container.GetInstance <IMessagingClient>); // Register data context container.RegisterSingleton(() => new OrganizationServiceDataContextFactory { LoggerFactory = container.GetInstance <ILoggerFactory>() }); //Register Email Service container.RegisterSingleton(() => new EmailService(emailSettings)); container.RegisterScoped(() => { var factory = container.GetInstance <OrganizationServiceDataContextFactory>(); var connectionString = hostBuilderContext.Configuration.GetConnectionString(nameof(OrganizationServiceDataContext)); return factory.CreateDbContext(connectionString); }); // Register repositories DependencyInjectionRegistration.RegisterRepositories(container); // Register services DependencyInjectionRegistration.RegisterServices(container); //Register subscribers DependencyInjectionRegistration.RegisterSubscribers(container); //Register healthchecks DependencyInjectionRegistration.RegisterHealthChecks(container); }) .AddGrpcService <ProfileController>() .AddGrpcService <OrganizationController>() .AddGrpcService <OrganizationUserController>() .AddGrpcService <GroupController>() .AddGrpcService <GroupAuthorizationController>() .AddGrpcService <AuthorizationController>() .AddGrpcService <UserInvitationController>() .AddGrpcService <HealthController>() .ConfigureGrpcServer( Assembly.GetEntryAssembly().GetName().Name, (hostBuilderContext) => { var config = new TracingConfig(); hostBuilderContext.Configuration.Bind(nameof(TracingConfig), config); return config; }, (hostBuilderContext, c, logger, serverServiceDefinitions, interceptors) => { var server = new Server(); var config = new GrpcConfig(); hostBuilderContext.Configuration.Bind(nameof(GrpcConfig), config); server.Ports.Add(new ServerPort(config.Host, config.Port, ServerCredentials.Insecure)); GrpcEnvironment.SetLogger(logger); serverServiceDefinitions .ToList() .ForEach(x => { server.Services.Add(x.Intercept(interceptors.ToArray())); }); return server; }) .ConfigureContainer <Container>(container => container.Verify())); }