An introduction to the CQRS (Command Query Responsibility Segregation) style of application architecture. Also touching on CQS (command query separation), Event Sourcing, Pub-Sub, and a little DDD.

1. Introduction to CQRS Approaches to System Architecture @NeilRobbins neil@computer.org

2. Tonights show is brought to by the following #tags #cqrs #glnet Hopefully not #fail, #WTF, or #WasteOfTime

3. What are we going to cover? Overview of the space CQS, Commands, Queries, DDD Simple CQRS Distributing CQRS Events Pub-Sub Eventual Consistency & Conflict Management Event Sourcing & CQRS What & Why? Some Code – Phew!

4. Introducing CQS

6. Easy to learn

7. Easy to remember

8. Withstand the tests of

9. Time

11. Command-Query Separation Principle Asking a question should not change the answer From: Object-Oriented Software Construction, 2nd Edition by Bertrand Meyer

12. Command-Query Separation Principle public interface IAmACqsExample { void DoSomething(); void DoSomething(Argument arg); Result GetSomething(); Result GetSomething(Argument arg); }

13. Introducing CQRS

14. So what is CQRS? Started out as: DDDD (Domain Driven Design + Distributed) Architectural CQS Now: Command Query Responsibility Segregation

15. So what is CQRS? – Part Deux A trinity Commands Queries Intent capturing UI

16. Simple CQRS Façadelient Logically distributable Commands Fully Consistent Queries

17. Commands in CQRS

19. Specific

20. Clearly represent client intent

21. Never past tense

23. CQRS Meets DDD But it doesn’t have to Core domain, supporting domains Need not be everywhere, some can be transaction script with Anaemic objects Ubiquitous language can lead to a clean interface Organising by aggregate root can make for simpler persistence Domain object should never be put in an invalid state!

24. Domain Objects: Forget Properties! public class Event { public string Name { get; set; } public int Venue { get; set; } public DateTime Date { get; set; } public IEnumerable<Session> Sessions { get; set; } } public class Session { public PresentationPresentation { get; set; } public string Location { get; set; } public DateTime Time { get; set; } }

25. Domain Objects: No Queries No Queries on your domain objects! Yes, that definitely includes any getters! Nada! (well maybe one, we’ll see that much later) All querying will be done through the Query system No binding to domain objects

26. Domain Objects: Control your mutations Only Command methods exposed They don’t return things either! Controlled mutation of state Ensures that aggregate roots do not enter into invalid states Ever! No IsValid() method (it’d be a query anyway)

27. Queries in CQRS

28. So what about Queries? They’re just queries They support the UI which should provide a Decision Support System Get quickly from the database Immutable objects

29. UI in CQRS

30. Intentful UI Shopping Cart Service Command Command Ratings Service Command Command Product Images Service Command Command Command Buying Choices Service Offers Service Bought Together Service

31. Intentful UI Captures Intent Aligns with commands Want to know WHY something changed, not just that it did Decide on an appropriate level of granularity, what’s important to your client/business? Customer address changed Or Customer moved house Or Customer’s address was incorrect

32. Intentful UI Uses the query infrastructure For display For decision support Should be a pit of success Commands should succeed Will contain logic, is typically rich

33. Distributing CQRS

34. Distributing CQRS Introduces some issues Keeping things in sync Faults become more likely Can give some wins Availability Scalability May/Should make some choices CAP Theorum

35. Introducing Events Something happened Past-tense Capture the details of the change Simple immutable data-structures Can be fed into MapReduce jobs Can be consumed more widely across the enterprise Integrate with other systems Send emails Update DataMarts/Warehouses

36. Façadelient Bus Commands Eventually Consistent Queries Handler

37. Keeping the Query Side in Sync Don’t have to forego Consistency Can perform 2 Phase Commits Can use quorums But there’s a price in the face of a fault write performance will degrade restrictive in the face of wide-geographical distribution Can use: RDBMS crazyness ;) PubSub

38. Subscriber Subscriber Publisher Subscribers Subscriber

39. Event Sourcing & CQRS

40. Event Sourcing …there are times when we don't just want to see where we are, we also want to know how we got there http://martinfowler.com/eaaDev/EventSourcing.html 2 Ways to persist changes Snapshot of current state Just the change itself

41. ID : 123 Name : The Art of War Author: Sun Tzu ISBN: 1234ABCD5678 Event: BookIsbnChanged NewValue: 4321DCBA8765

42. Time to See Some Code You didn’t think I’d make you watch me type did you? A small taste of Greg Young’s course (with minor changes) – link at the end.

43. First up a domain object namespaceProgNetDemo { public classCatalogItem { } } The domain object

44. A Command Method namespaceProgNetDemo { public classCatalogItem { public void Retire() { } } } Now we add a behaviour

45. Some State To Change namespaceProgNetDemo { public classCatalogItem { privatebool _retired; public void Retire() { } } } Some state that will need to be mutated

46. Guard the Mutation namespaceProgNetDemo { public classCatalogItem { privatebool _retired; public void Retire() { if (!_retired) thrownewInvalidOperationException(); } } } Protect the validity of the object!

47. Make the State Mutation A Domain Event namespaceProgNetDemo { public classCatalogItem { privatebool _retired; public void Retire() { if (!_retired) thrownewInvalidOperationException(); ApplyEvent(new RetiredEvent(_id)); } } } State mutations are a 2 phase activity

48. Need an Identifier for the Aggregate public classCatalogItem { privatebool _retired; privateGuid_id; public void Retire() { if (!_retired) thrownewInvalidOperationException(); ApplyEvent(new RetiredEvent(_id)); } } The event needs to know the Id of the Entity being updated

49. Create the Event publicclassRetiredEvent { privatereadonlyGuid _id; publicRetiredEvent(Guid id) { _id = id; } } Don’t need more state, in this case the name says it all Note it’s immutable

50. Need to be Able to Apply the Event public classCatalogItem { privatebool _retired; privateGuid_id; public void Retire() { if (!_retired) thrownewInvalidOperationException(); ApplyEvent(new RetiredEvent(_id)); } } Still need to write the code to apply the event.

51. Create a Base Class public abstract classAggregateRoot { protected voidApplyEvent(Event @event) { } } All Aggregate Roots will extend this class We’ll need to handle more than just the one type of event!

52. Create the Event Type public classEvent { } Would want to move the AggregateId into this base class

53. Have our RetiredEvent Inherit From the Base Type publicclassRetiredEvent : Event { privatereadonlyGuid _id; publicRetiredEvent(Guid id) { _id = id; } }

54. Still Need to Mutate the State public classCatalogItem : AggregateRoot { privatebool _retired; privateGuid_id; public void Retire() { if (!_retired) thrownewInvalidOperationException(); ApplyEvent(new RetiredEvent(_id)); } }

55. Create a Method to Handle the State Change From the Event public classCatalogItem : AggregateRoot { privatebool _retired; privateGuid_id; public void Retire() { if (!_retired) thrownewInvalidOperationException(); ApplyEvent(new RetiredEvent(_id)); } private voidApplyRetiredEvent(RetiredEvent @event) { _retired = true; } } This method will actually apply the event, that is mutate the state

56. Done!? public classCatalogItem : AggregateRoot { privatebool _retired; privateGuid_id; public void Retire() { if (!_retired) thrownewInvalidOperationException(); ApplyEvent(new RetiredEvent(_id)); } private voidApplyRetiredEvent(RetiredEvent @event) { _retired = true; } }

57. Need to Connect the Event with the Handler public classCatalogItem : AggregateRoot { privatebool _retired; privateGuid_id; publicCatalogItem() { RegisterHandler<RetiredEvent>(ApplyRetiredEvent); } public void Retire() { if (!_retired) thrownewInvalidOperationException(); ApplyEvent(new RetiredEvent(_id)); } private voidApplyRetiredEvent(RetiredEvent @event) { _retired = true; } } This could be done following a convention instead Note, this is the specific Event subtype – more later!

58. Allow Handlers to be Registered public classAggregateRoot { protected voidRegisterHandler<TEvent>(AppliesEvent<TEvent> handler) whereTEvent : Event { } protected voidApplyEvent(Event @event) { } } The delegate signature needs to be defined

59. Create the Delegate Signature public delegate voidAppliesEvent<TEvent>(TEvent @event) where TEvent : Event; public classAggregateRoot { protected voidRegisterHandler<TEvent>(AppliesEvent<TEvent> handler) whereTEvent : Event { } protected voidApplyEvent(Event @event) { } }

60. Need to Maintain the Registry public delegate voidAppliesEvent<TEvent>(TEvent @event) where TEvent : Event; public classAggregateRoot { private readonlyIDictionary<Type, Action<Event>> _handlerRegistry; protected voidRegisterHandler<TEvent>(AppliesEvent<TEvent> handler) whereTEvent : Event { var castHandler = DelegateAdjuster.CastArgument<Event, TEvent>(e => handler(e)); } protected voidApplyEvent(Event @event) { } } Will keep a list of handlers for each type of event. We’re storing the Action<Event>, but we want to call an Action<RetiredEvent>

61. Delegate Adjuster:From Greg Young’s Blog public class DelegateAdjuster { public static Action<TBase> CastArgument<TBase, TDerived>(Expression<Action<TDerived>> source) whereTDerived : TBase { if (typeof(TDerived) ==typeof(TBase)) { return (Action<TBase>)((Delegate)source.Compile()); } ParameterExpressionsourceParameter = Expression.Parameter(typeof(TBase),"source"); varresult = Expression.Lambda<Action<TBase>>( Expression.Invoke( source, Expression.Convert(sourceParameter, typeof(TDerived))), sourceParameter); return result.Compile(); } }

62. Need to Maintain the Registry public delegate voidAppliesEvent<TEvent>(TEvent @event) where TEvent : Event; public classAggregateRoot { private readonlyIDictionary<Type, Action<Event>> _handlerRegistry; protected voidRegisterHandler<TEvent>(AppliesEvent<TEvent> handler) whereTEvent : Event { var castHandler = DelegateAdjuster.CastArgument<Event, TEvent>(e => handler(e)); _handlerRegistry.Add(typeof(TEvent), castHandler); } protected voidApplyEvent(Event @event) { } } Store the handler having downcast it

63. Need to Apply the Event Still public classAggregateRoot { private readonlyIDictionary<Type, Action<Event>> _handlerRegistry; protected voidRegisterHandler<TEvent>(AppliesEvent<TEvent> handler) whereTEvent : Event { var castHandler = DelegateAdjuster.CastArgument<Event, TEvent>(e => handler(e)); _handlerRegistry.Add(typeof(TEvent), castHandler); } protected voidApplyEvent(Event @event) { Action<Event> handler; if (!_handlerRegistry.TryGetValue(@event.GetType(), out handler)) { throw newInvalidOperationException(); } handler(@event); } } If no handler for a mutation is registered, it’s a problem Invoke the handler

64. Need to Track Applied Events public delegate voidAppliesEvent<TEvent>(TEvent @event) where TEvent : Event; public classAggregateRoot { private readonlyIDictionary<Type, Action<Event>> _handlerRegistry; private readonlyICollection<Event> _events; protected voidRegisterHandler<TEvent>(AppliesEvent<TEvent> handler) whereTEvent : Event { var castHandler = DelegateAdjuster.CastArgument<Event, TEvent>(e => handler(e)); _handlerRegistry.Add(typeof(TEvent), castHandler); } protected voidApplyEvent(Event @event) { Action<Event> handler; if (!_handlerRegistry.TryGetValue(@event.GetType(), out handler)) { throw newInvalidOperationException(); } handler(@event); _events.Add(@event); } } Track the events that are being applied Make sure that the events are added.

65. All done now??? public classCatalogItem : AggregateRoot { privatebool _retired; privateGuid_id; publicCatalogItem() { RegisterHandler<RetiredEvent>(ApplyRetiredEvent); } public void Retire() { if (!_retired) thrownewInvalidOperationException(); ApplyEvent(new RetiredEvent(_id)); } private voidApplyRetiredEvent(RetiredEvent @event) { _retired = true; } }

66. Not Quite – pt. 1 Need to Expose the events for persistence & publishing Put a GetChanges() method on the AggregateRoot base class

67. Not Quite – pt. 2 Need to be able to rebuild the Aggregate from history Put a LoadFromHistory(IEnumerable<Event> events) method on the AggregateRoot base class Reapply the events Don’t track them as changes – overload apply event protected voidApplyEvent(Event @event, booltrackAsChange) if (add) _events.Add(@event);

68. Not Quite – pt. 3 Possibly memento pattern for snapshoting See Mark Nijhof’s blog & sample code on GitHub Possibly use a unit of work pattern for tracking changes

69. So what have we done here? A lot of the qualities we have just introduced normally exist at an infrastructure level Transaction/Redo Logs Replication Conflict Management By bringing them into the application we gain great power

70. Benefits of Event Sourcing Already We can build new stores for new services, we have the full set of available information ready We can rebuild stores for existing services We use the same mechanism for our Query Stores as we use for any other service in the Enterprise We aren’t just restricted to storing the Events Can send Emails based on them Can perform Complex Event Processing … The worlds your Oyster, you have the RAW MATERIAL

71. Some Other Benefits of Event Sourcing Also A Very Provable Audit Log Very Simple Horizontal Scaling More Granular Service Boundaries More Explicit Boundaries Can Replay Events in Debugging Scenarios Suits Behaviour Based Testing & Outside-In Development

72. What haven’t we looked at? Compensatory Actions & the Saga pattern How to persist the commands RDBMS? DocumentDB? HBase/Cassandra/Riak? File System? Fit with an SOA approach (it’s very good) Extreme scaling (for load, for geographies, for minimal latency) Versioning events Potential impact on project management Testing – suits Outside-In & Mockist –see #GOOS …

73. In Conclusion

74. NO SILVER BULLETS The coding is the EASY BIT Don’t need a grand framework The thinking & conversations is the HARD BIT As with any DDD project Need to understand the tradeoffs being made, and why

75. Referenced Material/Links Me - @Neil Robbins – neil@computer.org This Presentation - http://bit.ly/cqrsatgldotnet Greg Youngs: Course – http://bit.ly/gregscourse Blog – http://bit.ly/gregyoungsblog UdiDahans: Course – http://bit.ly/udiscourse Blog – http://bit.ly/udisblog Mark Nijhof’s sample code http://github.com/MarkNijhof/Fohjin Object-Oriented Software Construction, 2nd Edition by Bertrand Meyer