So let's talk about Ninject and how to bind decorators, I will illustrate it decorating Command Handlers in a CQRS architecture
Using this pattern will allow you to follow the Single Responsibility Principle in your command handlers.
Why? Let's take a look
So a typical command handler will validate its command and to achieve this we have several options:
Inside the command
public class GrantAccessToNightClubCommandHandler : ICommandHandler<GrantAccessToNightClub>
{
public void Handle(GrantAccessToNightClub command)
{
if (command.Age < 21)
{
throw new InvalidOperationException("Age was not satisfied");
}
//do stuff
}
}
So I don't like this approach because the validation is lost inside the handlers take a look to Make roles explicit by Udi Dahan
So let's try another approach
Injecting validators into the command handler
public class GrantAccessToNightClubCommandHandler : ICommandHandler<GrantAccessToNightClub>
{
private readonly IValdiatorRunner<GrantAccessToNightClub> _valdiatorRunner;
public GrantAccessToNightClubCommandHandler(IValdiatorRunner<GrantAccessToNightClub> valdiatorRunner)
{
_valdiatorRunner = valdiatorRunner;
}
public void Handle(GrantAccessToNightClub command)
{
_valdiatorRunner.Run(command);
//valid at this point
//do stuff
}
}
I won't go into detail about the IValidatorRunner implementation, but it loads dynamically validators for the specified command and runs them all
I used to like this technique since it provides a good separation of concerns, making the roles explicit but still... it looks like the command handler is doing too much, it's not following the SRP
Let's see the third option
Using Decorators
public class CommandHandlerValidator<TCommand> : ICommandHandler<TCommand> where TCommand : ICommand
{
private readonly IEnumerable<IValdiator<TCommand>> _valdiators;
private readonly ICommandHandler<TCommand> _commandHandler;
public CommandHandlerValidator(
IEnumerable<IValdiator<TCommand>> valdiators,
ICommandHandler<TCommand> commandHandler)
{
_valdiators = valdiators;
_commandHandler = commandHandler;
}
public void Handle(TCommand command)
{
_valdiators.ToList().ForEach(x => x.ApplyTo(command));
// wow everything is valid here, lets continue
_commandHandler.Handle(command);
}
}
public class GrantAccessToNightClubCommandHandler : ICommandHandler<GrantAccessToNightClub>
{
public void Handle(GrantAccessToNightClub command)
{
//do stuff
}
}
Wow, now it looks like we are following the SRP therefore everything starts to look simpler and easier to maintain and extend. Just by following the SRP. Wow it blows my mind
Now imagine that we want to apply authorization to our command handlers, again we can solve this by decorating them like:
public class CommandHandlerAuthenticator<TCommand> : ICommandHandler<TCommand> where TCommand : ICommand
{
private readonly ICommandHandler<TCommand> _commandHandler;
public CommandHandlerAuthenticator(ICommandHandler<TCommand> commandHandler)
{
_commandHandler = commandHandler;
}
public void Handle(TCommand command)
{
Authenticate(command);
//when authenticated simply...
_commandHandler.Handle(command);
}
private void Authenticate(TCommand command)
{
// some authentication
}
}
Now the trick is to inject the Decorators. I'm a big fan of Ninject so I will show you how to do it the Ninja style.
You need to define the injectors in the order that you want them, if you take a closer look to the previous code again, we have not specified what concrete command handler is going to be injected into the CommandHandlerValidator or the CommandHandlerAuthenticator. All we've defined is that a ICommandHandler will be injected somehow.
All this configuration will be done via our container. It's awesome
//we bind everythig except our command handlers since we will treat them as decorators
kernel.Bind(config =>
{
config.From(fromTypes.Select(x => x.Assembly))
.SelectAllClasses()
.Where(x => !x.IsAssignableToGenericType(typeof(ICommandHandler<>)))
.BindAllInterfaces();
});
kernel.Bind(config =>
{
config.From(fromTypes.Select(x => x.Assembly)).SelectAllClasses()
.Where(x => x.IsAssignableToGenericType(typeof(ICommandHandler<>)))
.BindAllInterfaces().Configure(x => x.WhenInjectedInto(typeof(CommandHandlerValidator<>)));
});
kernel.Bind(typeof(ICommandHandler<>)).To(typeof(CommandHandlerValidator<>))
.WhenInjectedInto(typeof(CommandHandlerAuthenticator<>));
kernel.Bind(typeof(ICommandHandler<>)).To(typeof(CommandHandlerAuthenticator<>));
This code can be read as follows (from bottom to top):
- When I ask an
ICommandHandler give me CommandHandlerAuthenticator
- Then when I'm injecting a
CommandHandlerAuthenticator give me a CommandHandlerValidator
- And finally, when I'm injecting a
CommandHandlerValidator give me my ICommandHandler
It's tricky I know... but it works great
This code could be improved maybe creating an Extension Method to bind decorators.
So when you test it like this:
var guard = kernel.Get<ICommandHandler<GrantAccessToNightClub>>();
guard.Handle(new GrantAccessToNightClub("jp", 21));
This is the output:
Test Name: TestMethod1
Test Outcome: Passed
Result StandardOutput:
Authenticating...
Valdiating: 21: Granted
Valdiation done, lets continue
Finally doing some work here...
Now the fun part, TEST IT
I don't know how to call this kind of test, I don't believe it's a unit test, integration test perhaps uhmm well I just call them Wiring tests
[TestMethod]
public void it_should_resolve_the_CommandHandlerDecorators()
{
var kernel = new StandardKernel();
var fromTypes = new[]
{
typeof (DecoratorTests)
};
//we bind everythig except our command handlers since we will treat them as decorators
kernel.Bind(config =>
{
config.From(fromTypes.Select(x => x.Assembly))
.SelectAllClasses()
.Where(x => !x.IsAssignableToGenericType(typeof(ICommandHandler<>)))
.BindAllInterfaces();
});
kernel.Bind(config =>
{
config.From(fromTypes.Select(x => x.Assembly)).SelectAllClasses()
.Where(x => x.IsAssignableToGenericType(typeof(ICommandHandler<>)))
.BindAllInterfaces().Configure(x => x.WhenInjectedInto(typeof(CommandHandlerValidator<>)));
});
kernel.Bind(typeof(ICommandHandler<>)).To(typeof(CommandHandlerValidator<>))
.WhenInjectedInto(typeof(CommandHandlerAuthenticator<>));
kernel.Bind(typeof(ICommandHandler<>)).To(typeof(CommandHandlerAuthenticator<>));
var field = typeof(KernelBase).GetField("bindings",
BindingFlags.Instance | BindingFlags.NonPublic);
field.Should().NotBeNull();
var bindingsMap = field.GetValue(kernel) as Multimap<Type, IBinding>;
bindingsMap.Should().NotBeNull();
bindingsMap.Should().NotBeEmpty();
var commandHandlerBindings = bindingsMap.SelectMany(x => x.Value)
.Where(x => x.Service.IsAssignableToGenericType(typeof(ICommandHandler<>))).ToList();
commandHandlerBindings.Should().NotBeNullOrEmpty();
commandHandlerBindings.Where(x => !x.Service.IsGenericTypeDefinition).ToList().ForEach(x =>
{
var handlers = kernel.GetAll(x.Service);
foreach (var instance in handlers)
{
instance.GetType().IsAssignableToGenericType(typeof(CommandHandlerAuthenticator<>)).Should().BeTrue();
// testing that the CommandHandlerValdiator was injected into CommandHandlerAuthenticator
VerifyInnerCommandHandler(instance, x.Service, typeof (CommandHandlerValidator<>),
typeof (CommandHandlerAuthenticator<>));
var innerCommandHandler = instance.GetType().GetField("_commandHandler",
BindingFlags.Instance | BindingFlags.NonPublic).GetValue(instance);
// testing that the ICommandHandler was injected into CommandHandlerValdiator
VerifyInnerCommandHandler(innerCommandHandler, x.Service, typeof (ICommandHandler<>),
typeof (CommandHandlerAuthenticator<>), typeof (CommandHandlerValidator<>));
}
});
}
private void VerifyInnerCommandHandler(object instance, Type service, Type expectedType, params Type[] notExpectedTypes)
{
var innerHandlerField = instance.GetType().GetField("_commandHandler",
BindingFlags.Instance | BindingFlags.NonPublic);
innerHandlerField.Should().NotBeNull();
var innerHandler = innerHandlerField.GetValue(instance);
innerHandler.GetType().IsAssignableToGenericType(expectedType).Should().BeTrue();
foreach (var notExpectedType in notExpectedTypes)
{
innerHandler.GetType().IsAssignableToGenericType(notExpectedType).Should().BeFalse();
}
Console.WriteLine("{0} should be: {1}", innerHandler.GetType(), service);
service.IsInstanceOfType(innerHandler).Should().BeTrue();
service.IsAssignableFrom(innerHandler.GetType()).Should().BeTrue();
innerHandler.GetType().IsAssignableToGenericType(expectedType).Should().BeTrue();
}
Ohh almost forgot, I'm using the following Type extension: IsAssignableToGenericType
There you go
Hope you have enjoyed it
