CuttingEdge | Little things I want to make , bundled together in one mod | Video Game library

Why doesn't this work in SI?

This doesn't work for the same reason as this doesn't work in .NET. This would only work when your ICommandHandler interface would be defined as covariant, but that is impossible because the TCommand is an input argument.

Let's remove the DI Container from the picture for a moment. Using plain-old C# code, the following is what you would like to accomplish:

You have to mark your controller with ActionFilterAttribute, instead of LogActionFilter.

It this a correct approach?

This answer might be a bit opinionated, but to me, this isn't the right approach. Your ICommandHandlerValidator interface serves no function, and your decorators can as easily derive directly from ICommandHandler.

On top of that, you are somewhat 'abusing' decorators to implement very specific logic, while decorators are best suited to implement very generic cross-cutting concerns.

Although you might argue that validation is very generic, your implementations aren't generic at all, since each decorator has logic that is specific to a single handler implementation. This leads to the situation that you get many decorators, and need to batch-register them.

What I typically like to do is to take a step back and look at the design. In your architecture you determined that business logic that mutates state is a certain artifact that deserves its own abstraction. You call this abstraction ICommandHandler. Not only does this allow you to clearly distinguish these particular type of components from other components in the system, it allows you to batch register them and apply cross-cutting concerns very effectively.

While looking at your code, however, it seems to me that logic that validates commands before they are executed by their command handler has importance of its own in your application. That means it deserves an abstraction of its own. For instance, you can call it ICommandValidator:

If a data object must be passed on your ViewModel then declare those in the constructor.

I posted the same question on Github (as Steven noted). https://github.com/simpleinjector/SimpleInjector/blob/v4.0.x/src/SimpleInjector.CodeSamples/ParameterConventionExtensions.cs contains an updated version of the convention-based approach although Steven/dotnetjunkie convinced me to take a different approach (using settings-objects).

It appears to talk about using commands instead of application services.

No, it does not talk about the command design pattern. There is a very clear, and crucial distinction between the command design pattern, and the CQRS-like patterns that are described on my blog and elsewhere.

The 'command' in the command design pattern combines data and behavior within the same class. With CQRS, the command is simply a message with no behavior. Behavior is moved to a 'handler' class. This separation is the driver that enables the maintainability and flexibility of this design.

1) Is this saying that you should have one command per command request in the Application Service Layer? Wouldn't this result in class explosion e.g. if you have 100 commands?

This is a very common misconception with developers. They think there is a direct relationship between the number of types in the system and the maintainability of that system, where an increase in classes means a decrease of maintainability.

The SOLID design patterns however favor small and focussed classes over big classes, because making classes smaller, can actually increase the maintainability of a system tremendously.

This is exactly what's going on here. This design should be viewed from the point of SOLID. My experience that, within the systems I refactored to that model, we saw a massive increase in maintainability in an order of magnitude, even though the amount of classes would as well increase with an order of magnitude.

Do not worry about the number of classes in your system. Just worry about maintainability.

This doesn't mean that project structure is irrelevant. It isn't. So find a good project structure for your commands, their handlers and their decorators.

2) What do you do with CQRS queries? Do you create regular application services for these?

You do exactly the same to queries as you do to commands. Each query should have its own query message and a handler, and optionally a result message class. This blog post describes how to design you queries.

3) What do you do with scenarios where you extract from the database (say an order); perform a command on the Order e.g. CalculateTax and then persist to the database? I assume the flow would be (is this right):

This is an atomic operation and should all be part of the command. When the command is executed, the order is loaded from the database, based on its ID captured in the command. The tax is calculated and the order is persisted as part of that (business) transaction.

This is a decision already made and should not be discussed in this topic.

Well.... if you insist :)

But at least prevent those queries from returning IEnumerable, but return IQueryable instead. The use of IEnumerable will cause all data to be returned from the database, even if you page over it.

That said, I'm not sure what is wrong with your code, but I want to suggest a slightly different approach: