One question that came up several times at DDD eXchange last week was CQRS: now we understand all the benefits, how do we begin migrating our existing applications towards this sort of architecture?
It’s something we’ve been chipping away at at work recently, and over a short series of posts I’d like to share some of the conventions and patterns we’ve been using to migrate traditional WPF client/WCF server systems towards a CQRS-aware architecture.
- Brownfield CQRS part 1 – Commands
- Brownfield CQRS part 2 – Command Handlers
- Brownfield CQRS part 3 – Queries, Parameters and Results
- Brownfield CQRS part 4 – Command Dispatcher
Note that WCF isn’t strictly required here — these patterns are equally applicable to most other RPC-based services (e.g. old ASMX web services).
CQRS recap
Command-Query Responsibility Segregation (CQRS) is based around a few key assumptions:
- All system behaviour is either a command that changes the state of the system, or a query that provides a view of that state (e.g. to display on screen).
- In most systems, the number of reads (queries) is typically an order of magnitude higher than than the number of writes (commands) — particularly on the web. It is therefore useful to be able to scale each side independently.
- Commands and queries have fundamentally different needs — commands favour a domain model, consistency and normalization, where reads are faster when highly denormalized e.g. table-per-screen with as little processing as possible in between. They often also portray the same objects differently — commands are typically small, driven by the needs of business transactions, where queries are larger, driven by UX requirements and sometimes including projections, flattening and aggregation.
- Using the same underlying model and storage mechanism for reads and writes couples the two sides together, and ensures at least one will suffer as a result.
CQRS completely separates (segregates) commands and queries at an architectural level, so each side can be designed and scaled independently of the other.
CQRS and WCF
The best way to to begin refactoring your architecture is to define clear interfaces — contracts — between components. Even if secretly, the components are huge messes on the inside, getting their interfaces (commands and queries) nailed down first sets the tone of the system, and allows you to begin refactoring each component at your discretion, without affecting others.
Each method on our WCF service must be either a command or a query. Let’s start with commands.
Commands
Each command method on your service must:
- Take a single command argument — a simple DTO/parameter object that encapsulates all the information required to execute the command.
- Return void — commands do not have return values. Only fault contracts may be used to throw an exception when a command fails.
Here’s an example:
[DataContract]
public class BookTableCommand : ICommand
{
[DataMember]
public DateTime TimeAndDay { get; set; }
[DataMember]
public int PartySize { get; set; }
[DataMember]
public string PartyName { get; set; }
[DataMember]
public string ContactPhoneNumber { get; set; }
[DataMember]
public string SpecialRequests { get; set; }
}
Commands carry all the information they need for someone to execute them — e.g. a command for booking a restaurant would tell us who is coming, when the booking is for, contact details, and any special requests (e.g. someone’s birthday). Commands like these are a special case of the Parameter Object pattern.
Now we’ve got our command defined, here’s the corresponding method on the WCF service endpoint:
[ServiceContract]
public interface IBookingService
{
[OperationContract]
void BookTable(BookTableCommand command);
}
One class per command
Command DTO classes are never re-used outside their single use case. For example, in the situation a customer wishes to change their booking (e.g. change it to a different day, or invite more friends), you would create a whole new ChangeBookingCommand, even though it may have all the same properties as the original BookTableCommand.
Why bother? Why not just create a single, general-purpose booking DTO and use it everywhere? Because:
- Commands are more than just the data they carry. The type communicates intent, and its name describes the context under which the command would be sent. This information would be lost with a general-purpose object.
- Using the same command DTO for two use cases couples them together. You couldn’t add a parameter for one use case without adding it for the other, for example.
What if I only need one parameter? Do I need a whole command DTO for that?
Say you had a command that only carried a reference to an object — its ID:
[DataContract]
public class CancelBookingCommand : ICommand
{
[DataMember]
public Guid BookingReference { get; set; }
}
Is it still worth creating an entire command DTO here? Why not just pass the GUID directly?
Actually, it doesn’t matter how many parameters there are:
- The intent of the command (in this case, cancelling a restaurant booking) is more important than the data it carries.
- Having a named command object makes this intent explicit. Not possible just with a GUID argument on your operation contract.
- Adding another parameter to the command (say, for example, an optional reason for cancelling) would require you to change the signature of the service contract. Ading another property to a command object would not.
- Command objects are much easier to pass around than a bunch of random variables (as we will see in the next post). For example, you can queue commands on a message bus to be processed later, or dispatch them out to a cluster of machines.
Why not just one overloaded Execute() method?
Instead of having one operation contract per command, why don’t you just use a single overloaded method like this?
[ServiceContract]
public interface IBookingService
{
[OperationContract]
void Execute<T>(T command) where T : ICommand;
}
You can but I wouldn’t recommend it. We’re still doing SOA here — a totally-generic contract like this makes it much harder for things like service discovery and other clients to see the endpoint’s capabilities.
Next: Part 2 – Command Handlers
June 15th, 2010 | 20 Comments
