ServiceProvider DoCreateAutomaticServices(SimpleServiceContainer?startupServices, IStObjMap current) { var services = new ServiceCollection(); var reg = new StObjContextRoot.ServiceRegister(TestHelper.Monitor, services, startupServices); var configureArgs = new AutomaticServicesConfigurationEventArgs(current, reg); var hIng = _automaticServicesConfiguring; if (hIng != null) { using (_monitor.Monitor.OpenInfo("Raising Automatic services configuring event.")) { hIng(this, configureArgs); } } if (!reg.AddStObjMap(current)) { Throw.Exception("AddStObjMap failed. The logs contains detailed information."); } var hEd = _automaticServicesConfigured; if (hEd != null) { using (_monitor.Monitor.OpenInfo("Raising Automatic services configured event.")) { hEd(this, configureArgs); } } return(services.BuildServiceProvider()); }
public void Our_ServiceRegister_maps_all_to_the_same_instance(bool scoped) { IServiceCollection services = new ServiceCollection(); var reg = new StObjContextRoot.ServiceRegister(TestHelper.Monitor, services); reg.Register(typeof(IA), typeof(A), scoped, allowMultipleRegistration: false); reg.Register(typeof(IB), typeof(A), scoped, allowMultipleRegistration: false); var sp = services.BuildServiceProvider(); var a = sp.GetRequiredService <IA>(); var b = sp.GetRequiredService <IB>(); var c = sp.GetRequiredService <A>(); a.Should().BeSameAs(b).And.BeSameAs(c); using (var scope = sp.CreateScope()) { var aS = scope.ServiceProvider.GetRequiredService <IA>(); var bS = scope.ServiceProvider.GetRequiredService <IB>(); var cS = scope.ServiceProvider.GetRequiredService <A>(); aS.Should().BeSameAs(bS).And.BeSameAs(cS); if (scoped) { a.Should().NotBeSameAs(aS); } else { a.Should().BeSameAs(aS); } } }
StObjContextRoot.ServiceRegister IStObjEngineTestHelperCore.GetFailedAutomaticServicesConfiguration(StObjCollector c, Func <StObjEngineConfiguration, StObjEngineConfiguration>?engineConfigurator, SimpleServiceContainer?startupServices) { IStObjMap map = DoCompileAndLoadStObjMap(c, engineConfigurator, useEmbeddedStObjMapIfPossible: false).Map; var reg = new StObjContextRoot.ServiceRegister(TestHelper.Monitor, new ServiceCollection(), startupServices); reg.AddStObjMap(map).Should().BeFalse("Service configuration failed."); return(reg); }
/// <summary> /// Configures this <see cref="IServiceCollection"/> by registering the <see cref="IStObjMap.StObjs"/> and /// the <paramref name="map"/> itself as Singletons, by calling <see cref="StObjContextRoot.RegisterStartupServicesMethodName"/> /// and then <see cref="StObjContextRoot.ConfigureServicesMethodName"/> on all the <see cref="IStObjObjectMap.FinalImplementations"/> that expose /// such methods and by registering the <see cref="IStObjServiceMap.SimpleMappings"/> and <see cref="IStObjServiceMap.ManualMappings"/> mappings. /// Any attempt to register an already registered service will be ignored and a warning will be emitted. /// <para> /// If the registration fails for any reason (file not found, type conflicts, etc.), a <see cref="CKException"/> is thrown. /// </para> /// </summary> /// <param name="services">This service collection to configure.</param> /// <param name="monitor">The monitor to use. Must not be null.</param> /// <param name="map">StObj map to register. Can not be null.</param> /// <param name="startupServices"> /// Optional simple container that may provide startup services. This is not used to build IRealObject /// (they must be independent of any "dynamic" services), however registered services become available to /// any <see cref="StObjContextRoot.ConfigureServicesMethodName"/> methods by parameter injection. /// </param> /// <returns>This services collection.</returns> public static IServiceCollection AddStObjMap(this IServiceCollection services, IActivityMonitor monitor, IStObjMap map, SimpleServiceContainer?startupServices = null) { var reg = new StObjContextRoot.ServiceRegister(monitor, services, startupServices); if (!reg.AddStObjMap(map)) { throw new CKException("AddStObjMap failed. The logs contains detailed information."); } return(services); }
/// <summary> /// Configure the services (does nothing here: this just tests the parameter /// injection of the startup services). /// </summary> /// <param name="register">This one is the only required parameter.</param> /// <param name="ambientObjects"> /// IStObjObjectMap is available: configuring services can rely on any IRealObject since they are already initialized (this /// is even available in the RegisterStartupServices). /// </param> /// <param name="superService">This is injected.</param> /// <param name="ext">This is injected.</param> /// <param name="optionalService"> /// This is injected if it exists in the StartupServices: startup services can be optional. /// </param> void ConfigureServices(StObjContextRoot.ServiceRegister register, IStObjObjectMap ambientObjects, SuperStartupService superService, TotallyExternalStartupServiceThatActAsAConfiguratorOfTheWholeSystem ext, IOptionalStartupService?optionalService = null) { ambientObjects.Obtain <IA1>().Should().BeSameAs(this); superService.Should().NotBeNull(); ext.Should().NotBeNull(); superService.Talk(register.Monitor); }
AutomaticServicesResult IStObjEngineTestHelperCore.CreateAutomaticServices(StObjCollector c, Func <StObjEngineConfiguration, StObjEngineConfiguration>?engineConfigurator, SimpleServiceContainer?startupServices, Action <StObjContextRoot.ServiceRegister>?configureServices) { var loadResult = DoCompileAndLoadStObjMap(c, engineConfigurator, true); var reg = new StObjContextRoot.ServiceRegister(TestHelper.Monitor, new ServiceCollection(), startupServices); reg.AddStObjMap(loadResult.Map).Should().BeTrue("Service configuration succeed."); configureServices?.Invoke(reg); return(new AutomaticServicesResult(loadResult, reg, reg.Services.BuildServiceProvider())); }
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member public void Deconstruct(out StObjCollectorResult collector, out IStObjMap map, out StObjContextRoot.ServiceRegister serviceRegister, out ServiceProvider services) { collector = CollectorResult; map = Map; serviceRegister = ServiceRegister; services = Services; }
internal AutomaticServicesResult(CompileAndLoadResult r, StObjContextRoot.ServiceRegister serviceRegister, ServiceProvider services) { CompileAndLoadResult = r; ServiceRegister = serviceRegister; Services = services; }
/// <summary> /// Initializes a new <see cref="AutomaticServicesConfigurationEventArgs"/>. /// </summary> /// <param name="map">The current StObjMap. Must not be null.</param> /// <param name="serviceRegister">The service register.</param> public AutomaticServicesConfigurationEventArgs(IStObjMap map, StObjContextRoot.ServiceRegister serviceRegister) { Throw.CheckNotNullArgument(map); StObjMap = map; ServiceRegister = serviceRegister; }
void ConfigureServices(StObjContextRoot.ServiceRegister register, TotallyExternalStartupServiceThatActAsAConfiguratorOfTheWholeSystem conf) { var impl = conf.AlwaysUseAlice ? typeof(PrivateAlwaysAliceProvider) : typeof(PrivateAliceOrBobProvider); register.Register(typeof(IAliceOrBobProvider), impl, isScoped: true, allowMultipleRegistration: false); }