The easiest way to learn design patterns: With C# code samples using .NET 6 templates
- Length: 364 pages
- Edition: 1
- Language: English
- Publisher: Independently published
- Publication Date: 2022-04-12
- ISBN-10: B09XT6LP9S
- ISBN-13: 9798801162188
- Sales Rank: #2334977 (See Top 100 Books)
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.
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
Donate to keep this site alive
1. Disable the AdBlock plugin. Otherwise, you may not get any links.
2. Solve the CAPTCHA.
3. Click download link.
4. Lead to download server to download.
