Design patters are something that you will need to get familiar with as a programmer who works with object oriented languages. And this is primarily because they represent well-defined solutions to common software development problems. So, instead of thinking through all the details of your solution, you can simply check if any of the existing design patterns can be used. You won’t have to reinvent the wheel.
The main problem with design patterns is that they are not necessarily easy to learn. Many developers, especially the ones who don’t have a lot of software-building experience, struggle with them. But if you do struggle with them, it may prevent you from getting a programming job at a reputable organization. After all, recruiting managers often ask questions about design patterns. Otherwise, not knowing design patterns will make you less effective as a software developer, which will slow down your career progress.
The main reason why design patterns are so hard to learn is because of the way they are normally taught. Usually, if you pick pretty much any book on design patterns or open pretty much any online article about them, it would provide a collection of design patterns that you would need to go through. You would then have to got through each of them, try your best to understand the principles behind it and only then try to figure out how to apply it in a real-life situation.
It's a tedious process that doesn't always bring about the right results. It's not uncommon for software developers to memorize just a handful of design patterns that they have been using in their own projects. The remaining ones have been forgotten as soon as they've been learned. And it's hard to figure out which design pattern applies in which situation if you only remember a handful of them.
This book provides a different approach. It uses a methodology that makes it easy to learn design patterns. So, you no longer have to brute-force your way through them. The process of effective learning is not about memorization. It's about associations. You learn new things easily when you can clearly see how new facts related to your existing knowledge. And this is precisely the method that this book is built around.
You won't have to brute-force your way into design patterns. In fact, you won't even start with the design patterns. First, we will go through a list of common problems that software developers are required to solve. Those are the things that every software developer can associate with. Even if you haven't faced a particular type of a problem yet, you will still be able to easily understand its description. For each of these problems, we will go through the design patterns that can solve it. And for each one of them, you will go through its core principle and the description of how it can solve this type of a problem. Only then you will be invited to examine this particular design pattern in detail, so you can understand how to implement it in your own code.
This structure of the book also makes it valuable as a reference book. Even when you don't know or don't remember design patterns, looking them up becomes easy. What you need to find is a description of the type of a problem you are trying to solve. And then you will be able to follow it to find the actual design patterns that you can apply to solve it.
Therefore this book is not only an effective learning tool. It's also a reference book that's incredibly easy to navigate. It's been structured in such a way that you'll be able to find the right answer in seconds.
Author(s): Fiodar Sazanavets
Publisher: Leanpub
Year: 2022
Language: English
Pages: 325
Table of Contents
Introduction
What design patterns are
Why would you want to learn design patterns
Why design patterns are hard to learn
The goal of this book
The structure of this book
About the author and his mission
Getting in touch
Helping to spread the word
Part 1: SOLID principles and why they are important
1. Single responsibility principle
What is single responsibility principle
The importance of single responsibility principle
The concept of class cohesion
Conclusion
2. Open-closed principle
What is open-closed principle
Implementing the open-closed principle in C#
Conclusion
3. Liskov substitution principle
Implementing Liskov substitution principle in C#
Conclusion
4. Interface segregation principle
What is interface segregation principle
Importance of interface segregation
When NotImplementedException is appropriate
5. Dependency inversion principle
What is dependency inversion principle
Why dependency inversion principle is important
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
Suitable design patterns
7. Making several exact copies of a complex object
Suitable design patterns
8. Using many instances of an object while keeping code running smoothly
Suitable design patterns
9. Using the same single instance of an object throughout the application
Suitable design patterns
10. Third party components aren’t directly compatible with your code
Suitable design patterns
11. Adding new functionality to existing objects that cannot be modified
Suitable design patterns
12. Accessing complex back-end logic from the presentation layer
Suitable design patterns
13. User interface and business logic are developed separately
Suitable design patterns
14. Building a complex object hierarchy
Suitable design patterns
15. Implementing complex conditional logic
Suitable design patterns
16. Multiple object instances of different types need to be able to communicate with each other
Suitable design patterns
17. Multiple stages of processing are needed
Suitable design patterns
18. The system is controlled by complex combinations of inputs
Suitable design patterns
19. Ability to undo an action that has been applied
Suitable design patterns
20. Ability to traverse a collection without knowing its underlying structure
Suitable design patterns
21. Creating a family of related algorithms
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
Prerequisites
Factory Method implementation example
Benefits of using Factory Method
Caveats of using Factory Method
25. Abstract Factory
Prerequisites
Abstract Factory implementation example
Benefits of using Abstract Factory
Caveats of using Abstract Factory
26. Builder
Prerequisites
Builder implementation example
Benefits of using Builder
Caveats of using Builder
27. Prototype
Prerequisites
Prototype implementation example
Benefits of using Prototype
Caveats of using Prototype
28. Singleton
Prerequisites
Singleton implementation example
Benefits of using Singleton
Caveats of using Singleton
Structural design patterns
29. Adapter
Prerequisites
Adapter implementation example
Benefits of using Adapter
Caveats of using Adapter
30. Bridge
Prerequisites
Bridge implementation example
Benefits of using Bridge
Caveats of using Bridge
31. Composite
Prerequisites
Composite implementation example
Benefits of using Composite
Caveats of using Composite
32. Decorator
Prerequisites
Decorator implementation example
Benefits of using Decorator
Caveats of using Composite
33. Facade
Prerequisites
Facade implementation example
Benefits of using Facade
Caveats of using Facade
34. Flyweight
Prerequisites
Flyweight implementation example
Benefits of using Flyweight
Caveats of using Flyweight
35. Proxy
Prerequisites
Proxy implementation example
Benefits of using Proxy
Caveats of using Proxy
Behavioral design patterns
37. Command
Prerequisites
Command implementation example
Benefits of using Command
Caveats of using Command
36. Chain of Responsibility
Prerequisites
Chain of Responsibility implementation example
Benefits of using Chain of Responsibility
Caveats of using Chain of Responsibility
38. Iterator
Prerequisites
Iterator implementation example
Benefits of using Iterator
Caveats of using Iterator
39. Mediator
Prerequisites
Mediator implementation example
Benefits of using Mediator
Caveats of using Mediator
40. Memento
Prerequisites
Memento implementation example
Benefits of using Memento
Caveats of using Memento
41. Observer
Prerequisites
Observer implementation example
Benefits of using Observer
Caveats of using Observer
42. State
Prerequisites
State implementation example
Benefits of using State
Caveats of using State
43. Strategy
Prerequisites
Strategy implementation example
Benefits of using Strategy
Caveats of using Strategy
44. Template Method
Prerequisites
Template Method implementation example
Benefits of using Template Method
Caveats of using Template Method
45. Visitor
Prerequisites
Visitor implementation example
Benefits of using Visitor
Caveats of using Visitor
Epilogue
