public static StartableEndpointWithExternallyManagedContainer CreateWithExternallyManagedContainer(EndpointConfiguration endpointConfiguration, IConfigureComponents externalContainer)
{
var settings = endpointConfiguration.Settings;
var assemblyScanningComponent = AssemblyScanningComponent.Initialize(settings.Get <AssemblyScanningComponent.Configuration>(), settings);
FinalizeConfiguration(endpointConfiguration, assemblyScanningComponent.AvailableTypes);
var hostingSettings = settings.Get <HostingComponent.Settings>();
var hostingConfiguration = HostingComponent.PrepareConfiguration(hostingSettings, assemblyScanningComponent, externalContainer);
if (hostingSettings.CustomObjectBuilder != null)
{
throw new InvalidOperationException("An internally managed container has already been configured using 'EndpointConfiguration.UseContainer'. It is not possible to use both an internally managed container and an externally managed container.");
}
hostingConfiguration.AddStartupDiagnosticsSection("Container", new
{
Type = "external"
});
var endpointCreator = new EndpointCreator(settings, hostingConfiguration);
endpointCreator.Initialize();
var startableEndpoint = new StartableEndpointWithExternallyManagedContainer(endpointCreator, hostingConfiguration);
//for backwards compatibility we need to make the IBuilder available in the container
externalContainer.ConfigureComponent(_ => startableEndpoint.Builder.Value, DependencyLifecycle.SingleInstance);
return(startableEndpoint);
}
public static ExternallyManagedContainerHost CreateWithExternallyManagedContainer(EndpointConfiguration endpointConfiguration, IServiceCollection serviceCollection)
{
var settings = endpointConfiguration.Settings;
CheckIfSettingsWhereUsedToCreateAnotherEndpoint(settings);
var assemblyScanningComponent = AssemblyScanningComponent.Initialize(settings.Get <AssemblyScanningComponent.Configuration>(), settings);
endpointConfiguration.FinalizeConfiguration(assemblyScanningComponent.AvailableTypes);
var hostingSettings = settings.Get <HostingComponent.Settings>();
var hostingConfiguration = HostingComponent.PrepareConfiguration(hostingSettings, assemblyScanningComponent, serviceCollection);
hostingConfiguration.AddStartupDiagnosticsSection("Container", new
{
Type = "external"
});
var endpointCreator = EndpointCreator.Create(settings, hostingConfiguration);
var externallyManagedContainerHost = new ExternallyManagedContainerHost(endpointCreator, hostingConfiguration);
return(externallyManagedContainerHost);
}
public static Configuration PrepareConfiguration(Settings settings, AssemblyScanningComponent assemblyScanningComponent, IServiceCollection serviceCollection)
{
var availableTypes = assemblyScanningComponent.AvailableTypes.Where(t => !t.IsAbstract && !t.IsInterface).ToList();
var configureComponentsAdapter = new CommonObjectBuilder(serviceCollection);
var configuration = new Configuration(settings,
availableTypes,
new CriticalError(settings.CustomCriticalErrorAction),
settings.StartupDiagnostics,
settings.DiagnosticsPath,
settings.HostDiagnosticsWriter,
settings.EndpointName,
configureComponentsAdapter,
settings.InstallationUserName,
settings.ShouldRunInstallers);
configureComponentsAdapter.ConfigureComponent(() => configuration.HostInformation, DependencyLifecycle.SingleInstance);
configureComponentsAdapter.ConfigureComponent(() => configuration.CriticalError, DependencyLifecycle.SingleInstance);
foreach (var installerType in availableTypes.Where(t => IsINeedToInstallSomething(t)))
{
configureComponentsAdapter.ConfigureComponent(installerType, DependencyLifecycle.InstancePerCall);
}
foreach (var registration in settings.UserRegistrations)
{
registration(configureComponentsAdapter);
}
return(configuration);
}
public static async Task <IStartableEndpoint> CreateWithInternallyManagedContainer(EndpointConfiguration endpointConfiguration, CancellationToken cancellationToken = default)
{
var settings = endpointConfiguration.Settings;
CheckIfSettingsWhereUsedToCreateAnotherEndpoint(settings);
var assemblyScanningComponent = AssemblyScanningComponent.Initialize(settings.Get <AssemblyScanningComponent.Configuration>(), settings);
endpointConfiguration.FinalizeConfiguration(assemblyScanningComponent.AvailableTypes);
var serviceCollection = new ServiceCollection();
var hostingConfiguration = HostingComponent.PrepareConfiguration(settings.Get <HostingComponent.Settings>(), assemblyScanningComponent, serviceCollection);
hostingConfiguration.AddStartupDiagnosticsSection("Container", new
{
Type = "internal"
});
var endpointCreator = EndpointCreator.Create(settings, hostingConfiguration);
var hostingComponent = HostingComponent.Initialize(hostingConfiguration, serviceCollection, true);
var serviceProvider = serviceCollection.BuildServiceProvider();
var startableEndpoint = endpointCreator.CreateStartableEndpoint(serviceProvider, hostingComponent);
hostingComponent.RegisterBuilder(serviceProvider);
await hostingComponent.RunInstallers(cancellationToken).ConfigureAwait(false);
return(new InternallyManagedContainerHost(startableEndpoint, hostingComponent));
}
public static async Task <IStartableEndpoint> CreateWithInternallyManagedContainer(EndpointConfiguration endpointConfiguration)
{
var settings = endpointConfiguration.Settings;
CheckIfSettingsWhereUsedToCreateAnotherEndpoint(settings);
var assemblyScanningComponent = AssemblyScanningComponent.Initialize(settings.Get <AssemblyScanningComponent.Configuration>(), settings);
endpointConfiguration.FinalizeConfiguration(assemblyScanningComponent.AvailableTypes);
var hostingSetting = settings.Get <HostingComponent.Settings>();
var useDefaultBuilder = hostingSetting.CustomObjectBuilder == null;
var container = useDefaultBuilder ? new LightInjectObjectBuilder() : hostingSetting.CustomObjectBuilder;
var commonObjectBuilder = new CommonObjectBuilder(container);
IConfigureComponents internalContainer = commonObjectBuilder;
IBuilder internalBuilder = commonObjectBuilder;
//for backwards compatibility we need to make the IBuilder available in the container
internalContainer.ConfigureComponent(_ => internalBuilder, DependencyLifecycle.SingleInstance);
var hostingConfiguration = HostingComponent.PrepareConfiguration(settings.Get <HostingComponent.Settings>(), assemblyScanningComponent, internalContainer);
if (useDefaultBuilder)
{
hostingConfiguration.AddStartupDiagnosticsSection("Container", new
{
Type = "internal"
});
}
else
{
var containerType = internalContainer.GetType();
hostingConfiguration.AddStartupDiagnosticsSection("Container", new
{
Type = containerType.FullName,
Version = FileVersionRetriever.GetFileVersion(containerType)
});
}
var endpointCreator = EndpointCreator.Create(settings, hostingConfiguration);
var hostingComponent = HostingComponent.Initialize(hostingConfiguration);
var startableEndpoint = endpointCreator.CreateStartableEndpoint(internalBuilder, hostingComponent);
hostingComponent.RegisterBuilder(internalBuilder, true);
await hostingComponent.RunInstallers().ConfigureAwait(false);
return(new InternallyManagedContainerHost(startableEndpoint, hostingComponent));
}
public static Configuration PrepareConfiguration(Settings settings, AssemblyScanningComponent assemblyScanningComponent, IServiceCollection serviceCollection)
{
var availableTypes = assemblyScanningComponent.AvailableTypes.Where(t => !t.IsAbstract && !t.IsInterface).ToList();
var configuration = new Configuration(settings,
availableTypes,
new CriticalError(settings.CustomCriticalErrorAction),
settings.StartupDiagnostics,
settings.DiagnosticsPath,
settings.HostDiagnosticsWriter,
settings.EndpointName,
serviceCollection,
settings.InstallationUserName,
settings.ShouldRunInstallers,
settings.UserRegistrations);
return configuration;
}
public static Configuration PrepareConfiguration(Settings settings, AssemblyScanningComponent assemblyScanningComponent, IConfigureComponents container)
{
var availableTypes = assemblyScanningComponent.AvailableTypes.Where(t => !t.IsAbstract && !t.IsInterface).ToList();
var configuration = new Configuration(settings,
availableTypes,
new CriticalError(settings.CustomCriticalErrorAction),
settings.StartupDiagnostics,
settings.DiagnosticsPath,
settings.HostDiagnosticsWriter,
settings.EndpointName,
container);
container.ConfigureComponent(() => configuration.HostInformation, DependencyLifecycle.SingleInstance);
container.ConfigureComponent(() => configuration.CriticalError, DependencyLifecycle.SingleInstance);
foreach (var registration in settings.UserRegistrations)
{
registration(container);
}
return(configuration);
}
public static async Task <IStartableEndpoint> CreateWithInternallyManagedContainer(EndpointConfiguration endpointConfiguration)
{
var settings = endpointConfiguration.Settings;
CheckIfSettingsWhereUsedToCreateAnotherEndpoint(settings);
var assemblyScanningComponent = AssemblyScanningComponent.Initialize(settings.Get <AssemblyScanningComponent.Configuration>(), settings);
endpointConfiguration.FinalizeConfiguration(assemblyScanningComponent.AvailableTypes);
var serviceCollection = new MicrosoftExtensionsDependencyInjection.ServiceCollection();
var hostingConfiguration = HostingComponent.PrepareConfiguration(settings.Get <HostingComponent.Settings>(), assemblyScanningComponent, serviceCollection);
hostingConfiguration.AddStartupDiagnosticsSection("Container", new
{
Type = "internal"
});
var endpointCreator = EndpointCreator.Create(settings, hostingConfiguration);
var hostingComponent = HostingComponent.Initialize(hostingConfiguration);
var containerOptions = new ContainerOptions
{
EnableVariance = false
}.WithMicrosoftSettings();
var serviceProvider = serviceCollection.CreateLightInjectServiceProvider(containerOptions);
var startableEndpoint = endpointCreator.CreateStartableEndpoint(serviceProvider, hostingComponent);
hostingComponent.RegisterBuilder(serviceProvider, true);
await hostingComponent.RunInstallers().ConfigureAwait(false);
return(new InternallyManagedContainerHost(startableEndpoint, hostingComponent));
}
