Although popular, personally, I have never met anyone who would have implemented more than half of the mentioned Design Patterns. Yet sometimes, even unintentionally, I have heard of a pattern that has been implemented over and over as a common solution, usually by my classmates. Do you have such a thing? Maybe you could match its structure to the one described in a book? Or are you familiar with its name? Personally, the
most used one would be <a href="https://en.wikipedia.org/wiki/Singleton_pattern" target="_blank" rel="noopener nofollow">Singleton</a>. I hope to learn yours. I was introduced to it when I was making my first steps in Unity Engine. Implementing it was a way to have some common things set up between the scenes, if I remember correctly, and from then on, I often used it in different technologies, from Java to TypeScript.

Smiley Face

Krzysztof

A developer shares their experience with design patterns, noting that while many patterns exist, few are commonly implemented in practice. The Singleton pattern stands out as their most frequently used pattern, first encountered while working with Unity Engine for managing shared state across scenes, and later applied across various technologies including Java and TypeScript. The post invites others to share their most commonly used design patterns.

What is your most used design pattern

I don’t think I can pick just one. Factory Method, Template Method, and Strategy come up a lot. We use Spring Boot, so Singleton is always there, but we also have actual Singleton classes.
I’ve probably used Decorator and Visitor. And one of the first big things I build used the Builder pattern. In hindsight, I should not have used Builder as it has made the code more verbose than is probably necessary, but I was left to my own devices as a junior dev…
And not in this book, but mentioned somewhere, is the “method object.” I can’t remember where I saw that one, but I’m pretty sure it’s a Beck/Fowler concept. It really helps our code have readability and separation of concerns, not to mention reusability.

This is a very good topic, raising the point of whether all patterns are truly used.
I believe it’s difficult to use them all, but the mistake I see in many teams, companies, or developers is not knowing how to properly explore how each pattern can help them in their project. For example, you mentioned the Singleton pattern, which you used most because it’s a simple pattern that was used for a long time, even in universities and parallel courses, as well as the Strategy and Factory patterns. We end up internalizing these patterns and neglecting to explore others, not that it’s mandatory, but it can be helpful.
Some time ago I made a post here and on my blog about a similar discussion on TDD (Test-Driven Development) from another post, so I raised my opinion on whether people know what it is and if they really use it, since it’s a methodology…
I think what’s really lacking is exploration because they are concepts and patterns, where even mixing one with another is normal. So, we shouldn’t be stuck with the patterns presented to us but rather explore them all if possible. This book is very good for that very purpose.

IDK about most used, but my favorite is fly-weight and it’s my favorite because before I was really knowledgeable about design patterns (at-least enough to really implement any from the top of my head) I had an issue where my system was consistently running out of memory on a large collection bein returned by the ORM and taking forever before doing so. I implemented the fly-wheel pattern and moved everything i could to a shared instance of those attributes (example: one set of ‘Product Sizes’ or ‘Product Colors’, things like that and as soon as the refactor was done, file got saved, page got refreshed (it was PHP) &amp; before I could even cross my fingers / begin to pray to the code gods, the page in question had reloaded fully w/ all the rows in my grid beautifully hydrated. My jaw dropped to the floor at the sheer amount of performance gain / how awesomely graceful and simple it was to ultimately solve my problem by using that kind of pattern thinking. Between seeing it solve my problem right away &amp; implications of writing better code using design patterns my mind was blown. I felt like I had levelled up for the first time in a long time. For that, I’ll always have a soft spot for the fly-wheel pattern in my heart and toolbox!

If you’re using modern .NET, and using DI for your services, you’ll do a mix of something like:
<pre><code class="language-cs">builder.Services.AddTransient&lt;IOperationTransient, Operation&gt;();
builder.Services.AddScoped&lt;IOperationScoped, Operation&gt;();
builder.Services.AddSingleton&lt;IOperationSingleton, Operation&gt;();
</code></pre>
Source: <a href="https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-10.0#lifetime-and-registration-options" target="_blank" rel="noopener nofollow">https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-10.0#lifetime-and-registration-options</a>
So you would probably have:
God Tier: Singleton, Strategy, Iterator
S-Tier: Factory, Observer, Facade
A-Tier: Decorator, Adapter, Command
B-Tier: Builder, Proxy, State
Personally, I almost always end up using Factory, Strategy and without knowing I use Iterator and Singleton (because C# will always use them)