public void Process(Type type, Registry registry)
{
if (type.ImplementsInterfaceTemplate(typeof(IQueryHandler<,>)))
{
MvcQueryRegistrar.BuildQueryRegistrarForHandler(type).RegisterQuery(registry);
}
if (type.ImplementsInterfaceTemplate(typeof(ICommandHandler<>)))
{
MvcCommandRegistrar.BuildCommandRegistrarForHandler(type).RegisterCommand(registry);
}
}
private static void RegisterQueryForDefaultCrudCommands(Type type, Type genericCommand, Registry registry)
{
if (type.ImplementsInterfaceTemplate(genericCommand))
{
MvcQueryRegistrar.BuildQueryRegistrarForCrudCommand(type, genericCommand).RegisterQuery(registry);
}
}
public bool MatchesType(Type type)
{
if (typeof(IHandler).IsAssignableFrom(type)) return false;
return
type.ImplementsInterfaceTemplate(typeof(IListener<>));
}
private static void RegisterTypes(Type type, Registry registry, Type genericCommand, Type handler, Type handlerInterface)
{
if (type.ImplementsInterfaceTemplate(genericCommand))
{
Type interfaceType = type.FindFirstInterfaceThatCloses(genericCommand);
Type domainEntityType = interfaceType.GetGenericArguments()[0];
Type closesCommandHandlerInterface = handlerInterface.MakeGenericType(type, domainEntityType);
Type closesCommandHandler = handler.MakeGenericType(type, domainEntityType);
registry.For(closesCommandHandlerInterface)
.Add(closesCommandHandler);
}
}
public void Process(Type type, Registry registry)
{
if (type.ImplementsInterfaceTemplate(typeof(ICreateCommand<>)))
{
Type interfaceType = type.FindFirstInterfaceThatCloses(typeof(ICreateCommand<>));
Type domainEntityType = interfaceType.GetGenericArguments()[0];
var openIdGeneratorType = typeof(IIdGenerator<,>);
var closedIdGeneratorType =
openIdGeneratorType.MakeGenericType(domainEntityType, typeof(Guid?));
var openGuidGenerator = typeof(GuidIdGenerator<>);
var closedGuidIdGenerator = openGuidGenerator.MakeGenericType(domainEntityType);
registry.For(closedIdGeneratorType).Use(closedGuidIdGenerator);
}
}
public void ProcessHandler(Type type, Registry registry, Type typeInterface, Type handlerInterface, Type concreteHandler)
{
if (type.ImplementsInterfaceTemplate(typeInterface))
{
Type interfaceType = type.FindFirstInterfaceThatCloses(typeInterface);
Type[] genericArguments = interfaceType.GetGenericArguments();
Type closeActionProcessprInterface =
handlerInterface.MakeGenericType(genericArguments);
Type closesActionProcessor =
concreteHandler.MakeGenericType(genericArguments);
registry.For(closeActionProcessprInterface).Use(closesActionProcessor);
registry.AddType(interfaceType, type);
}
}
public void ProcessFacade(Type type, Registry registry, Type facadeInterface, Type genericFacadeInterface, Type concreteFacade)
{
if (type.ImplementsInterfaceTemplate(genericFacadeInterface))
{
var interfaceType = type.FindFirstInterfaceThatCloses(genericFacadeInterface);
var commandMessageTypes = interfaceType.GetGenericArguments();
var closesQuerryProcessor =
concreteFacade.MakeGenericType(commandMessageTypes);
registry.AddType(closesQuerryProcessor);
registry.AddType(interfaceType, type);
}
if (facadeInterface.IsAssignableFrom(type) && !type.IsInterface)
{
registry.AddType(facadeInterface, type);
}
}
public void Process(Type type, Registry registry)
{
if (!type.ImplementsInterfaceTemplate(typeof (IFormHandler<>))) return;
var interfaceType = type.FindFirstInterfaceThatCloses(typeof (IFormHandler<>));
var commandMessageType = interfaceType.GetGenericArguments()[0];
var openCommandMethodResultType = typeof (FormActionResult<>);
var closedCommandMethodResultType = openCommandMethodResultType.MakeGenericType(commandMessageType);
var openActionMethodInvokerType = typeof (IActionMethodResultInvoker<>);
var closedActionMethodInvokerType =
openActionMethodInvokerType.MakeGenericType(closedCommandMethodResultType);
var openCommandMethodResultInvokerType = typeof (CommandMethodResultInvoker<>);
var closedCommandMethodResultInvokerType =
openCommandMethodResultInvokerType.MakeGenericType(commandMessageType);
registry.For(closedActionMethodInvokerType).Use(closedCommandMethodResultInvokerType);
}
public bool MatchesType(Type type)
{
return type.ImplementsInterfaceTemplate(typeof (IHandle<>));
}
public bool MatchesType(Type type)
{
return type.ImplementsInterfaceTemplate(typeof(IListenTo<>.All)) ||
type.ImplementsInterfaceTemplate(typeof(IListenTo<>.SentToMe)) ||
type.ImplementsInterfaceTemplate(typeof(IListenTo<>.ThatSatisfy));
}
public bool MatchesType(Type type)
{
bool matchesType = type.ImplementsInterfaceTemplate(typeof(IEventHandler<>));
return matchesType;
}
public bool MatchesType(Type type)
{
Console.WriteLine(type.ToString());
return type.ImplementsInterfaceTemplate(typeof(IListener<>));
}
