Intentions & Interfaces Making Patterns Concrete

1. Intentions & InterfacesMaking Patterns Concrete Udi Dahan – The Software Simplist Enterprise Development Expert & SOA Specialist Session Code: <Session code>

2. Books, and books, and books, and books…

3. Flexibility brings many benefits

4. Agenda Intentional Interfaces Data Access Service Layer Validation

5. Preventing rigidity from creeping in

6. Existing solutions Strategy Pattern Visitor Pattern

7. Visitor pattern Requires a method for each ConcreteElement

8. Strategy pattern Requires all classes to contain a strategy

9. Danger Application Code May cause a collapse of application structure Infrastructure Code at Co ion de lic App Infrastructure Code

10. Doing too muchcan hurt Y ou A ren‘t G onna N eed I t

11. What needs to flex? “Prediction is very difficult, • especially if it's about the future.” -- Niels Bohr Physics Nobel prize 1922

12. Bolt on flexibility where you need it

13. Flexibility you seek? Hmm? Made your roles explicit, have you? No? That is why you fail.

14. Make Roles Explicit

15. Some well known interfaces ISerializable IFather IHusband Serializable IGoToWork IComeHome IWashTheDishes

18. Intentional Interfaces Data Access Service Layer Validation

19. Custom validation before persistence

20. The old “object-oriented” way • boolIsValidating; .Validate(); Customer .Validate(); Address * .Validate(); Order But what if we start here? Persistence .Persist(c);

21. Too many roles

22. Make Roles Explicit

23. Roles as Marker Interfaces IEntity Customer Order IValidator<T> ValidationError Validate(T entity); where T : IEntity

24. Validation Implementation IValidator<T> Customer CustomerValidator: IValidator<Customer> ValidationError Validate(T entity); ValidationError Validate(Customer entity);

25. Extensible validation when persisting .Persist(Customer) Persistence Service Locator Get<IValidator<Customer>> new Validate(Customer) Customer Validator

26. But that’s not Object OrientedIs it?

27. Extensible and Object Oriented Customer Validator .Validate(); Customer

28. Application code stays simple Application Code .Persist(Customer) Infrastructure Code

29. Intentional Interfaces Data Access Service Layer Validation

30. Regular Service Layer Code publicvoidMake_Customer_Preferred(Guid id) { using (ISession s = ORM.Open_Session()) using (ITransactiontx = s.Begin_Transaction()) { Customer c = s.Get<Customer>(id); c.Make_Preferred(); tx.Commit(); } }

31. Loading graphs of objects public class Customer { publicvoidMake_Preferred() { foreach(Order o inthis.UnshippedOrders) foreach(Orderlineolino.OrderLines) ol.Discount(10.Percent); } } Lazy Loading

32. Dangers of Lazy Loading public class Customer { publicvoidMake_Preferred() { foreach(Order o inthis.UnshippedOrders) foreach(Orderlineolino.OrderLines) ol.Discount(10.Percent); } } DB

33. Loading graphs of objects Making a customer “preferred” Adding an Order Customer Customer Order OrderLine

34. Different “Fetching Strategies” for the same customer

35. Make Roles Explicit

36. Use interfaces to differentiate roles IMakeCustomerPreferred IAddOrdersToCustomer void MakePreferred(); void AddOrder(Order o); Customer

37. Service Layer Specifies Role publicvoidMake_Customer_Preferred(Guid id) { using (ISession s = ORM.Open_Session()) using (ITransactiontx = s.Begin_Transaction()) { IMakeCustomerPreferred c = s.Get<IMakeCustomerPreferred>(id); c.Make_Preferred(); tx.Commit(); } }

38. Infrastructure Roles The Fetching Strategy

39. Extend behavior around role IMakeCustomerPreferred IAddOrdersToCustomer void MakePreferred(); void AddOrder(Order o); Customer T MakeCustomerPreferredFetchingStrategy : IFetchingStrategy<IMakeCustomerPreferred> Inherits string Strategy { get { return “UnshippedOrders, OrderLines”; } } IFetchingStrategy<T>

40. The Extensible Way .Get<IMakeCustomerPreferred>(id) Persistence Load graph Service Locator Get<IFetchingStrategy<IMakeCustomerPreferred>> DB new Get strategy Make_Customer_Preferred_Fetching_Strategy

41. Intentional Interfaces Data Access Service Layer Validation

42. Regular Service Layer Code Customer Service void Change_Address(Guid id, Address a); void Make_Preferred(Guid id); voidChange_Credit(Credit c);

43. How developers collaborate…

44. Applying the pattern again… IMessage IMessageHandler<T> void Handle(T message); where T : IMessage

45. The messages: Change_Address_Msg Make_Preferred_Msg Change_Credit_Msg IMessage

46. The message handlers: H1: H2: H3: IMessageHandler<T> void Handle(T message); IMessageHandler<Change_Address_Msg> IMessageHandler<Make_Preferred_Msg> IMessageHandler<Change_Credit_Msg>

47. Now everybody’s happy…

48. There can be more than one… H1: H4: Change_Address_Msg IMessageHandler<Change_Address_Msg> IMessageHandler<Change_Address_Msg>

49. Putting it all together… .Handle(m); Service Locator .Handle(m); GetAll<IMessageHandler<Change_Address_Msg>> new H1 H4

50. Intentional Interfaces Data Access Service Layer Validation