The easiest way to learn design patterns

Introduction

1. What design patterns are
2. Why would you want to learn design patterns
3. Why design patterns are hard to learn
4. The goal of this book
5. The structure of this book

About the author and his mission

1. Getting in touch
2. Helping to spread the word

UML conventions used in the book

1. Basic component
2. Association
3. Dependency
4. Implementation
5. Inheritance

Part 1: SOLID principles and why they are important

1. Single responsibility principle

1. What is single responsibility principle
2. The importance of the single responsibility principle
3. The concept of class cohesion
4. Conclusion

2. Open-closed principle

1. What is open-closed principle
2. Implementing the open-closed principle in C#
3. Conclusion

3. Liskov substitution principle

1. Implementing Liskov substitution principle in C#
2. Conclusion

4. Interface segregation principle

1. What is interface segregation principle
2. Importance of interface segregation
3. When NotImplementedException is appropriate

5. Dependency inversion principle

1. What is dependency inversion principle
2. Why the dependency inversion principle is important
3. Dependency inversion is not only useful in unit tests

Part 2: The problems that design patterns are intended to solve

6. Not knowing what object implementations you’ll need ahead of time

1. Suitable design patterns

7. Making several exact copies of a complex object

1. Suitable design patterns

8. Using many instances of an object while keeping code running smoothly

1. Suitable design patterns

9. Using the same single instance of an object throughout the application

1. Suitable design patterns

10. Third-party components aren’t directly compatible with your code

1. Suitable design patterns

11. Adding new functionality to existing objects that cannot be modified

1. Suitable design patterns

Accessing complex back-end logic from the presentation layer

1. Suitable design patterns

13. User interface and business logic are developed separately

1. Suitable design patterns

14. Building a complex object hierarchy

1. Suitable design patterns

15. Implementing complex conditional logic

1. Suitable design patterns

16. Multiple object instances of different types need to be able to communicate with each other

1. Suitable design patterns

17. Multiple stages of processing are needed

1. Suitable design patterns

18. The system is controlled by complex combinations of inputs

1. Suitable design patterns

19. Ability to undo an action that has been applied

1. Suitable design patterns

20. Ability to traverse a collection without knowing its underlying structure

1. Suitable design patterns

21. Creating a family of related algorithms

1. Suitable design patterns

22. Summary of the problems design patterns are intended to solve

Part 3: Design patterns demonstrated in C#

23. Design pattern categories

Creational design patterns

24. Factory Method

1. Prerequisites
2. Factory Method implementation example
3. Benefits of using Factory Method
4. Caveats of using Factory Method

25. Abstract Factory

1. Prerequisites
2. Abstract Factory implementation example
3. Benefits of using Abstract Factory
4. Caveats of using Abstract Factory

26. Builder

1. Prerequisites
2. Builder implementation example
3. Benefits of using Builder
4. Caveats of using Builder

27. Prototype

1. Prerequisites
2. Prototype implementation example
3. Benefits of using Prototype
4. Caveats of using Prototype

28. Singleton

1. Prerequisites
2. Singleton implementation example
3. Benefits of using Singleton
4. Caveats of using Singleton

Structural design patterns

29. Adapter

1. Prerequisites
2. Adapter implementation example
3. Benefits of using Adapter
4. Caveats of using Adapter

30. Bridge

1. Prerequisites
2. Bridge implementation example
3. Benefits of using Bridge
4. Caveats of using Bridge

31. Composite

1. Prerequisites
2. Composite implementation example
3. Benefits of using Composite
4. Caveats of using Composite

32. Decorator

1. Prerequisites
2. Decorator implementation example
3. Benefits of using Decorator
4. Caveats of using Composite

33. Facade

1. Prerequisites
2. Facade implementation example
3. Benefits of using Facade
4. Caveats of using Facade

34. Flyweight

1. Prerequisites
2. Flyweight implementation example
3. Benefits of using Flyweight
4. Caveats of using Flyweight

35. Proxy

1. Prerequisites
2. Proxy implementation example
3. Benefits of using Proxy
4. Caveats of using Proxy

Behavioral design patterns

36. Chain of Responsibility

1. Prerequisites
2. Chain of Responsibility implementation example
3. Benefits of using Chain of Responsibility
4. Caveats of using Chain of Responsibility

37. Command

1. Prerequisites
2. Command implementation example
3. Benefits of using Command
4. Caveats of using Command

38. Iterator

1. Prerequisites
2. Iterator implementation example
3. Benefits of using Iterator
4. Caveats of using Iterator

39. Mediator

1. Prerequisites
2. Mediator implementation example
3. Benefits of using Mediator
4. Caveats of using Mediator

40. Memento

1. Prerequisites
2. Memento implementation example
3. Benefits of using Memento
4. Caveats of using Memento

41. Observer

1. Prerequisites
2. Observer implementation example
3. Benefits of using Observer
4. Caveats of using Observer

42. State

1. Prerequisites
2. State implementation example
3. Benefits of using State
4. Caveats of using State

43. Strategy

1. Prerequisites
2. Strategy implementation example
3. Benefits of using Strategy
4. Caveats of using Strategy

44. Template Method

1. Prerequisites
2. Template Method implementation example
3. Benefits of using Template Method
4. Caveats of using Template Method

45. Visitor

1. Prerequisites
2. Visitor implementation example
3. Benefits of using Visitor
4. Caveats of using Visitor

Epilogue