2. What Are Design Patterns?
Well-understood code patterns
Solve common problems
Create common pattern vocabulary
Speed up design and development
Encourage creating design standards
3. Useful Design Principles
Prefer Composition over Inheritance
Program to abstractions instead of
concrete implementations
Design loosely coupled components
Encapsulate what varies
Hide the likely-to-change code behind an
interface
4. Time-Tested Design Principles
S – Single Responsibility Principle
One reason to change per class
O – Open-Closed Principle
Classes open for extension, closed for modification
L – Liskov Substitution Principle
Classes can be substituted if designed to be
referenced via their public contracts
I – Interface Segregation Principle
Interfaces should not be bloated
D – Dependency Inversion Principle
Classes should not be responsible for creating their
dependencies
6. Example Anti Patterns
The Arrowhead
Constructor Over-Injection
Gold Plating
Interface Bloat
God Object
Magic Literals
Reinventing The Wheel
7. The Gang Of Four
Authors of the canonical book Design
Patterns: Elements of Reusable Object-
Oriented Software
Erich Gamma, Richard Helm, Ralph
Johnson, John Vlissides
Main theme 1: Program to an interface
instead of an implementation
Main theme 2: Favor composition over
inheritance
9. Enterprise Design Patterns
Patterns found in enterprise applications
Major proponent: Martin Fowler of
Thoughtworks
Enterprise patterns go beyond GoF
patterns
Often specific to technology stacks
11. What Makes It Useful?
Repeatable pattern to execute tasks as
objects
Allows parameterizing command
invokers with different commands
Allows undo operations
Meta-Command Pattern allows creating
composite commands
Decouples worker objects from client
objects
12. Practical Uses
Background processing agents
Allow third-party vendors to create and
distribute custom commands
Supports queuing requests
Facilitates logging requests
By serializing/deserializing objects to/from log
files
Log contains history of all command objects
Allows implementing transaction semantics
15. What Makes It Useful?
Facilitates implementing the open-
closed principle
Allows adding new functionality without
modifying existing classes
Promotes composition over inheritance
Promotes iterative development
16. Practical Uses
Dynamically creating specialized objects
Provide flexible API with object
decorators
Example uses in the .Net framework
BufferedStream decorates MemoryStream
20. Pattern: Lazy Load
Avoid performing time-consuming
operations unless unavoidable
Load data from database or an external
service as late as possible
Cache fetched data for as long as
feasible
Reduce database and/or network load
21. Code Sample
Private Shared ReadOnly Property
DTSearchIndexLocation() As String
Get
If String.IsNullOrEmpty(_dtSearchIndexLocation)
Then
' fetch from database and assign to
_dtSearchIndexLocation
End If
Return _dtSearchIndexLocation
End Get
End Property
23. Further Study
Writings of The Godfather of Enterprise
Design Patterns a.k.a. Martin Fowler
Martinfowler.com
Head-First Design Patterns by O’Reilly
Writings of Uncle Bob a.k.a. Robert C.
Martin
ButUncleBob.com, blog.objectmentor.com
Presentations by Jeremy Miller
codebetter.com/blogs/jeremy.miller
Hinweis der Redaktion
Say more with less, shared vocabulary speeds up development and reduces chances of confusion and misunderstanding.
Constructor Over Injection: If the class can function without a particular dependent object, it shouldn’t demand it in the constructor.