public void FindAndRegister_ExecutingAssembly_RegistersAllComponents()
{
var services = new ServiceCollection();
var options = new IntermediumOptions();
options.Scan(typeof(ServiceRegistrarTests));
ServiceRegistrar.FindAndRegister(services, options);
var provider = services.BuildServiceProvider();
provider.GetService <Core.ServiceProvider>().Should().NotBeNull();
provider.GetService <IMediator>().Should().BeOfType <Mediator>();
new[]
{
typeof(ExceptionHandlingMiddleware <,>),
typeof(PostProcessingMiddleware <,>),
typeof(PreProcessingMiddleware <,>)
}
.All(middleware => services.Any(x => x.ImplementationType == middleware))
.Should()
.BeTrue();
provider.GetServices <IQueryHandler <QueryTest, int> >().Should().HaveCount(1);
provider.GetServices <IQueryHandler <CommandTest, VoidUnit> >().Should().HaveCount(1);
provider.GetServices <INotificationHandler <NotificationTest> >().Should().HaveCount(2);
provider.GetServices <IQueryExceptionHandler <CommandTest, VoidUnit> >().Should().HaveCount(3);
}
private static IEnumerable <TypeInfo> GetOpenGenericInterfaces(
IServiceCollection services,
IntermediumOptions options)
{
yield return(typeof(INotificationHandler <>).GetTypeInfo());
void AddMiddleware(Type middleware) => services.AddTransient(typeof(IMiddleware <,>), middleware);
if (options.RegisterExceptionHandlingMiddleware)
{
AddMiddleware(typeof(ExceptionHandlingMiddleware <,>));
yield return(typeof(IQueryExceptionHandler <,>).GetTypeInfo());
}
if (options.RegisterPostProcessingMiddleware)
{
AddMiddleware(typeof(PostProcessingMiddleware <,>));
yield return(typeof(IQueryPostProcessor <,>).GetTypeInfo());
}
if (options.RegisterPreProcessingMiddleware)
{
AddMiddleware(typeof(PreProcessingMiddleware <,>));
yield return(typeof(IQueryPreProcessor <,>).GetTypeInfo());
}
}
public static void FindAndRegister(IServiceCollection services, IntermediumOptions options)
{
RegisterCoreServices(services, options);
var definedTypes = new HashSet <TypeInfo>(options.ScanTargets.SelectMany(x => x.DefinedTypes));
var openGenericInterfaces = GetOpenGenericInterfaces(services, options).ToList();
var closedGenericTypes = definedTypes.Where(x => !x.IsOpenGeneric()).ToList();
FindAndRegister(services, closedGenericTypes, typeof(IQueryHandler <,>).GetTypeInfo(), true);
foreach (var openGenericInterface in openGenericInterfaces)
{
FindAndRegister(services, closedGenericTypes, openGenericInterface, false);
foreach (var definedType in definedTypes)
{
if (definedType.IsConcrete() &&
definedType.IsOpenGeneric() &&
definedType.FindCloseInterfaces(openGenericInterface).Any())
{
services.AddTransient(openGenericInterface.AsType(), definedType.AsType());
}
}
}
}
public void Scan_SameAssemblyMultipleTimes_ScansOnlyUniqueAssemblies()
{
var type = typeof(IntermediumOptionsTests);
var options = new IntermediumOptions();
options.Scan(type, type, type);
options.ScanTargets.Should().HaveCount(1);
}
private static void RegisterCoreServices(IServiceCollection services, IntermediumOptions options)
{
services.TryAddTransient <ServiceProvider>(x => x.GetService);
services.Add(new ServiceDescriptor(
typeof(IMediator),
options.MediatorImplementationType,
options.MediatorLifetime
));
}
