public void Integration()
{
var sc = new ServiceCollection();
sc.AddSingleton("Foo Bar");
var builder = sut.CreateBuilder(sc);
Assert.NotNull(builder);
var provider = sut.CreateServiceProvider(builder);
Assert.Equal("Foo Bar", provider.GetRequiredService <string>());
}
public IServiceProvider CreateServiceProvider(IServiceCollection services)
{
var containerBuilder = ((ContainerBuilderAdapter)services).Adaptee;
var serviceProvider = factory.CreateServiceProvider(containerBuilder);
return(serviceProvider);
}
public IServiceProvider CreateServiceProvider(object containerBuilder)
{
if (_serviceProviderFactory == null)
{
throw new InvalidOperationException("CreateBuilder must be called before CreateServiceProvider");
}
return(_serviceProviderFactory.CreateServiceProvider((TContainerBuilder)containerBuilder));
}
private static IServiceProvider BuildServiceProvider <TContainerBuilder>(
IServiceProviderFactory <TContainerBuilder> factory,
IServiceCollection services)
{
var builder = factory.CreateBuilder(services);
return(factory.CreateServiceProvider(builder));
}
public override SuperSocketHostBuilder <TReceivePackage> UseServiceProviderFactory <TContainerBuilder>(IServiceProviderFactory <TContainerBuilder> factory)
{
_serviceProviderBuilder = (context, services) =>
{
var containerBuilder = factory.CreateBuilder(services);
ConfigureContainerBuilder(context, containerBuilder);
return(factory.CreateServiceProvider(containerBuilder));
};
return(this);
}
private IServiceProvider GetProviderFromFactory(IServiceCollection collectionClone, TenantContext <TTenant> tenantContext)
{
ServiceProvider provider = collectionClone.BuildServiceProvider();
IServiceProviderFactory <IServiceCollection> factory = provider.GetService <IServiceProviderFactory <IServiceCollection> >();
using (provider)
{
return(factory.CreateServiceProvider(factory.CreateBuilder(collectionClone)));
}
}
/// <summary>
/// Registers a <see cref="IServiceProviderFactory{TBuilder}" /> instance to be used to create the <see cref="IServiceProvider" />.
/// </summary>
/// <param name="factory">The <see cref="IServiceProviderFactory{TBuilder}" />.</param>
/// <param name="configure">
/// A delegate used to configure the <typeparamref T="TBuilder" />. This can be used to configure services using
/// APIS specific to the <see cref="IServiceProviderFactory{TBuilder}" /> implementation.
/// </param>
/// <typeparam name="TBuilder">The type of builder provided by the <see cref="IServiceProviderFactory{TBuilder}" />.</typeparam>
/// <remarks>
/// <para>
/// <see cref="ConfigureContainer{TBuilder}(IServiceProviderFactory{TBuilder}, Action{TBuilder})"/> is called by <see cref="Build"/>
/// and so the delegate provided by <paramref name="configure"/> will run after all other services have been registered.
/// </para>
/// <para>
/// Multiple calls to <see cref="ConfigureContainer{TBuilder}(IServiceProviderFactory{TBuilder}, Action{TBuilder})"/> will replace
/// the previously stored <paramref name="factory"/> and <paramref name="configure"/> delegate.
/// </para>
/// </remarks>
public void ConfigureContainer <TBuilder>(IServiceProviderFactory <TBuilder> factory, Action <TBuilder>?configure = null) where TBuilder : notnull
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
_createServiceProvider = () =>
{
var container = factory.CreateBuilder(Services);
configure?.Invoke(container);
return(factory.CreateServiceProvider(container));
};
}
private IServiceProvider GetProvider <TContainerType>(IServiceProvider applicationProvider, IServiceCollection serviceCollection)
{
IServiceProviderFactory <TContainerType> providerFactory =
applicationProvider.GetService <IServiceProviderFactory <TContainerType> >()
?? throw new NoServiceProviderFactoryException("Failed to resolve service provider factory");
TContainerType container = providerFactory.CreateBuilder(serviceCollection);
foreach (Action <TContainerType> configureMethods in _configureContainerDelegates.OfType <Action <TContainerType> >())
{
configureMethods(container);
}
return(providerFactory.CreateServiceProvider(container));
}
public ContainerAdapter(IServiceProviderFactory <TContainerBuilder> serviceProviderFactory, ContainerSettings <TContainerBuilder> containerSettings)
{
serviceCollectionAdapter = new ServiceCollectionAdapter(containerSettings.ServiceCollection);
serviceProviderAdapter = new Lazy <ServiceProviderAdapter>(() =>
{
locked = true;
var containerBuilder = serviceProviderFactory.CreateBuilder(containerSettings.ServiceCollection);
foreach (var customConfiguration in containerSettings.ContainerConfigurations)
{
customConfiguration(containerBuilder);
}
var serviceProvider = serviceProviderFactory.CreateServiceProvider(containerBuilder);
return(new ServiceProviderAdapter(serviceProvider));
}, LazyThreadSafetyMode.ExecutionAndPublication);
}
private IServiceProvider GetProviderFromFactory(IServiceCollection collection)
{
ServiceProvider provider = collection.BuildServiceProvider();
IServiceProviderFactory <IServiceCollection> service =
provider.GetService <IServiceProviderFactory <IServiceCollection> >();
if (service == null || service is DefaultServiceProviderFactory)
{
return(provider);
}
using (provider)
{
return(service.CreateServiceProvider(service.CreateBuilder(collection)));
}
}
public IServiceProvider CreateServiceProvider(object containerBuilder) => _serviceProviderFactory.CreateServiceProvider((TContainerBuilder)containerBuilder);
public IServiceProvider CreateServiceProvider(object containerBuilder)
{
return(_serviceProviderFactory.CreateServiceProvider((TContainerBuilder)containerBuilder));
}
/// <summary>
/// Specifies how the <see cref="IServiceProvider"/> for this silo is configured.
/// </summary>
/// <param name="builder">The host builder.</param>
/// <param name="factory">The service provider configuration method.</param>
/// <returns>The silo builder.</returns>
public static ISiloHostBuilder UseServiceProviderFactory <TContainerBuilder>(ISiloHostBuilder builder, IServiceProviderFactory <TContainerBuilder> factory)
{
return(builder.UseServiceProviderFactory(services => factory.CreateServiceProvider(factory.CreateBuilder(services))));
}
