public void ConfigureServices(IServiceCollection services, IConfiguration configuration)
{
// Create a fresh service registry...
var serviceRegistry = new NamedServiceRegistry <TService>();
// The inherited class maps service names to factory functions...
AddNamedServices(configuration, serviceRegistry);
// Register the named service factory for injection by the host application...
services.AddSingleton <INamedServiceFactory <TService> >(new NamedServiceFactory <TService>(serviceRegistry));
}
public void Can_Add_MixtureOf_Registrations()
{
var namedRegistrations = new NamedServiceRegistry<AnimalService>(GetDefaultServiceProvider());
namedRegistrations.AddSingleton("A", new AnimalService() { SomeProperty = "A" });
namedRegistrations.AddSingleton("B", new LionService() { SomeProperty = "B", SomeOtherProperty = true });
namedRegistrations.AddSingleton<TigerService>("C");
namedRegistrations.AddSingleton("D");
Assert.NotNull(namedRegistrations["A"]);
Assert.NotNull(namedRegistrations["B"]);
Assert.NotNull(namedRegistrations["C"]);
}
public void Can_Dispose_Of_SingletonInstances()
{
var disposable = new DisposableTigerService() { SomeProperty = "Should be disposed." };
var disposableShouldNotBeDisposed = new DisposableTigerService() { SomeProperty = "Should NOT be disposed." };
using (var namedRegistrations = new NamedServiceRegistry<AnimalService>(GetDefaultServiceProvider()))
{
namedRegistrations.AddSingleton("A", disposableShouldNotBeDisposed);
namedRegistrations.AddSingleton("B", disposable, registrationOwnsInstance: true); // This param defaults to false, must specifiy true if you want instance to be disposed by service provider dispose().
}
Assert.False(disposableShouldNotBeDisposed.WasDisposed);
Assert.True(disposable.WasDisposed);
}
public void Can_Add_Singleton_Type_Registrations()
{
var namedRegistrations = new NamedServiceRegistry<AnimalService>(GetDefaultServiceProvider());
namedRegistrations.AddSingleton("A");
namedRegistrations.AddSingleton<BearService>("B");
var registeredA = namedRegistrations["A"];
Assert.NotNull(registeredA);
Assert.Equal(Lifetime.Singleton, registeredA.Lifetime);
Assert.True(registeredA.RegistrationOwnsInstance);
Assert.Equal(typeof(AnimalService), registeredA.ImplementationType);
var registeredB = namedRegistrations["B"];
Assert.NotNull(registeredB);
Assert.Equal(Lifetime.Singleton, registeredB.Lifetime);
Assert.True(registeredB.RegistrationOwnsInstance);
Assert.Equal(typeof(BearService), registeredB.ImplementationType);
}
public static IServiceCollection AddNamed <TService>(this IServiceCollection services, Action <NamedServiceRegistry <TService> > configure)
{
services.AddSingleton <NamedServiceRegistry <TService> >(sp =>
{
var registry = new NamedServiceRegistry <TService>(sp);
configure(registry);
return(registry);
});
services.AddScoped <NamedServiceResolver <TService> >();
var serviceType = typeof(TService);
services.AddScoped <Func <string, TService> >(sp => new Func <string, TService>(name =>
{
var resolver = sp.GetRequiredService <NamedServiceResolver <TService> >();
return(resolver.Get(name));
}));
return(services);
}
public void Can_Add_Singleton_Instance_Registrations()
{
var namedRegistrations = new NamedServiceRegistry<AnimalService>(GetDefaultServiceProvider());
namedRegistrations.AddSingleton("A", new AnimalService() { SomeProperty = "A" });
namedRegistrations.AddSingleton("B", new AnimalService() { SomeProperty = "B" });
namedRegistrations.AddSingleton("C", new BearService() { SomeProperty = "C" });
namedRegistrations.AddSingleton("D", new LionService() { SomeProperty = "D", SomeOtherProperty = true });
namedRegistrations.AddSingleton("E", new LionService() { SomeProperty = "E" }, registrationOwnsInstance: true);
var registeredA = namedRegistrations["A"];
var registeredB = namedRegistrations["B"];
Assert.NotNull(registeredA);
Assert.Equal(Lifetime.Singleton, registeredA.Lifetime);
Assert.False(registeredA.RegistrationOwnsInstance);
Assert.Null(registeredA.ImplementationType);
Assert.NotNull(registeredB);
Assert.Equal(Lifetime.Singleton, registeredB.Lifetime);
Assert.False(registeredB.RegistrationOwnsInstance);
Assert.Null(registeredB.ImplementationType);
var registeredC = namedRegistrations["C"];
var registeredD = namedRegistrations["D"];
Assert.NotNull(registeredC);
Assert.Equal(Lifetime.Singleton, registeredC.Lifetime);
Assert.False(registeredC.RegistrationOwnsInstance);
Assert.Null(registeredC.ImplementationType);
Assert.NotNull(registeredD);
Assert.Equal(Lifetime.Singleton, registeredD.Lifetime);
Assert.False(registeredD.RegistrationOwnsInstance);
Assert.Null(registeredD.ImplementationType);
var registeredE = namedRegistrations["E"];
Assert.True(registeredE.RegistrationOwnsInstance);
}
public NamedServiceResolver(NamedServiceRegistry <TService> registry, IServiceProvider serviceProvider)
{
Registry = registry;
_serviceProvider = serviceProvider;
_scopedInstanceCache = new Lazy <ScopedInstanceCache <TService> >();
}
