For quite some time, I've been fascinated by the 23 Gang of Four (GoF) design patterns - powerful concepts applicable to a wide range of application design scenarios. The Gang of Four, namely Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, introduced these patterns in their book "Design Patterns: Elements of Reusable Object-Oriented Software."
As a junior .NET developer, I embarked on the journey of learning these patterns using examples from authoritative sources. However, I found many of the existing examples to be excessively intricate for beginners. These examples often tried to demonstrate the patterns in real-world applications, which initially seemed like a great idea.
Unfortunately, the complexity of these real-world contexts often obscured the true purpose and intent of the patterns for newcomers like me. I struggled to distinguish between essential pattern components and specific language-related details.
Thankfully, with the advent of ChatGPT, I discovered an opportunity to co-create beginner-friendly, even real-world beginner-friendly examples. In a GitHub repository, I compiled a .NET Solution comprising various console application projects that leverage the power of AI to teach design patterns in the most effective way possible.
tigerbluejay
/
GOF-Design-Patterns-Generic-Real-World-Examples-by-AI
This .NET Solution contains 65 Projects demonstrating the GoF Design Patterns with annotated Generic, Real-world, and .NET Specific examples generated by ChatGPT, edited and corrected by me.
GOF Design Patterns
Generic and Real-World Examples by ChatGPT AI
This Solution is a working compilation of the GOF Design Patterns Projects contain anotated generic examples, real world examples and .NET examples or implementations of the patterns.
I asked ChatGPT to rank the patterns in order of complexity for human understanding and it provided the following ranked list which I recommend when reading through and debugging the examples.
- Singleton
- Factory Method
- Observer
- Strategy
- Template Method
- Adapter
- Decorator
- Command
- Proxy
- Iterator
- Composite
- Facade
- State
- Bridge
- Abstract Factory
- Builder
- Prototype
- Mediator
- Visitor
- Chain of Responsibility
- Flyweight
- Memento
- Interpreter
Below each pattern I also transcribe here the most common scenarios where they are used.
SINGLETON
The Singleton design pattern is used when we need to ensure that only one instance of a class is created throughout the execution of a program. It restricts the instantiation of a class to a single object and…
To begin, I asked ChatGPT to rank the patterns from easiest to hardest for human developers to comprehend. While the ranking is influenced by each developer's background, I found that ChatGPT did a commendable job organizing the patterns.
In the repo's readme file, you'll find the six most common scenarios for each of the patterns, and the ranking of the patterns themselves. Note that inside the .NET solution the patterns are numbered in order of difficulty also, from easiest to hardest to learn. Following this order will make the learning transition smooth.
Within the solution, you'll find AI-generated examples. However, I had to meticulously edit many of them since ChatGPT didn't always get the code right on the first attempt (and sometimes required specific targeting to generate accurate code). Additionally, I provided annotations to clarify the purpose, function, and syntax of these examples.
Each pattern begins with a generic example named after the pattern itself (e.g., "Decorator" for the Decorator pattern). After that, there's a real-world example, which can either be a context-specific .NET application or an enriched implementation of the generic example with some variations. Moreover, with the exception of the first four patterns, each pattern includes a .NET example demonstrating its application in a real-world .NET scenario. These .NET examples are more complex than the generic ones and often represent a step up from the real-world examples.
For optimal learning, I recommend following the numbered order of the patterns and starting with the generic example, along with its annotations. Next, explore the Real World example, also with annotations, and finally, delve into the .NET application example, which may have additional annotations as well.
By following this approach, I believe you'll gain a thorough understanding of these design patterns and their practical applications in .NET development. Happy learning!
Top comments (1)
Fantastic! What a great use of AI - to give us practical examples the books traditionally can't or won't do. I'll take a look at that repo - thanks!