The document discusses making roles explicit in software design to achieve flexibility and extensibility. It recommends using interfaces to define roles and role-specific behavior. This allows application code to specify roles and infrastructure code to provide role-specific implementations and fetching strategies. When roles are well-defined through interfaces, new behaviors can be added without changing existing code.

1. Intentions & Interfaces
Making patterns concrete
Udi Dahan – The Software Simplist
.NET Development Expert & SOA Specialist
www.UdiDahan.com
email@UdiDahan.com

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

3. Flexibility brings many benefits

4. Preventing rigidity from creeping in

5. Existing solutions
Strategy Pattern
Visitor Pattern

6. Visitor pattern
Requires a method for
each ConcreteElement

7. Strategy pattern
Requires all classes to
contain a strategy

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

9. Doing too
much can hurt
ou
ren„t
onna
eed
t

10. “Prediction is very
difficult, especially if
it's about the future.”
-- Niels Bohr
Physics Nobel prize 1922

11. Bolt on flexibility where you need it

12. Sometimes called “hooks”
Application Code
Infrastructure Code
New
New
Code
Code

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
Java Serializable
IGoToWork
IComeHome
IWashTheDishes

18. Custom entity validation before persistence

19. The old “object-oriented” way
bool IsValidating;
.Validate();
Customer .Validate();
* Address
.Validate();
Order
But what if we start here?
Persistence

20. It looks like our
objects have
too many roles
to play

21. Make roles explicit

22. Add a marker interface here,
and an interface there….
IEntity
where T : IEntity
IValidator<T>
ValidationError Validate(T entity);

23. The first part is trivial:
IEntity
Customer
Order

24. The second part is more interesting
IValidator<T>
ValidationError Validate(T entity);
Customer
CustomerValidator: IValidator<Customer>
ValidationError Validate(Customer entity);

25. Add a dash of
Inversion of Control
Service-Locator style

26. The extensible way
.Persist(Customer)
Persistence
Service Locator Get<IValidator<Customer>>
new
Validate(Customer)
Customer Validator

27. But that’s not
Object Oriented
Is it?

28. Extensible and Object Oriented
.Persist(Customer)
Persistence
Service Locator Get<IValidator<Customer>>
new Validate(Customer)
Customer Validator
.Validate();
Customer

29. And application code stays simple
Application Code
.Persist(Customer)
Infrastructure Code

30. Loading objects from the DB
public class Customer
{
public void MakePreferred()
{
foreach(Order o in this.UnshippedOrders)
foreach(Orderline ol in o.OrderLines)
ol.Discount(10.Percent);
}
}
Lazy Loading

31. Dangers of Lazy Loading
public void MakePreferred()
{
foreach(Order o in this.UnshippedOrders)
foreach(Orderline ol in o.OrderLines)
ol.Discount(10.Percent);
}
DB

32. Loading objects from the DB
Making a customer
Adding an Order
“preferred”
Customer
Customer
Order
OrderLine

33. Need Different “Fetching Strategies”
public class ServiceLayer
{
public void MakePreferred(Id customerId)
{
Customer c = ORM.Get<Customer>(customerId);
c.MakePreferred();
}
public void AddOrder(Id customerId, OrderInfo o)
{
Customer c = ORM.Get<Customer>(customerId);
c.AddOrder(o);
}
}

34. Make
Roles
Explicit

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

36. Application code specifies role
public class ServiceLayer
{
public void MakePreferred(Id customerId)
{
IMakeCustomerPreferred c = ORM
.Get< IMakeCustomerPreferred>(customerId);
c.MakePreferred();
}
public void AddOrder(Id customerId, OrderInfo o)
{
IAddOrdersToCustomer c = ORM
.Get< IAddOrdersToCustomer>(customerId);
c.AddOrder(o);
}
}

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

38. The extensible way
.Get<IMakeCustomerPreferred>(id)
Persistence
Service Locator
Get<IFetchingStrategy<
new
IMakeCustomerPreferred>>
Get strategy
MakeCustomerPreferredFetchingStrategy

39. And the pattern repeats…
IMessage
where T : IEntity
IMessageHandler<T>
void Handle(T message);

40. Once your roles
made explicit,
you have…
Extensibility and
flexibility -
simple they will be

41. Thank you
Udi Dahan – The Software Simplist
.NET Development Expert & SOA Specialist
www.UdiDahan.com
email@UdiDahan.com