DEV Community: Shirin Monzavi

𝐂𝐨𝐮𝐧𝐭 𝐕𝐬 𝐂𝐨𝐮𝐧𝐭() 𝐢𝐧 𝐂# 𝐋𝐢𝐬𝐭<𝐓>?

Shirin Monzavi — Thu, 20 Nov 2025 08:28:07 +0000

𝐖𝐡𝐚𝐭 𝐢𝐬 𝐂𝐨𝐮𝐧𝐭 𝐢𝐧 𝐋𝐢𝐬𝐭<𝐓>?
Count is a property of many collections in .Net and its value represents the number of elements in the collection. Its time complexity is O(1).

𝐖𝐡𝐚𝐭 𝐢𝐬 𝐂𝐨𝐮𝐧𝐭() 𝐢𝐧 𝐋𝐢𝐬𝐭<𝐓>?
Count() is LINQ extension method for counting elements of a List.
At first, LINQ checks the type, if it is type of collection, it uses the count property. Otherwise, it iterates through all elements to count them. Its time complexity is O(n).

💯𝐃𝐨 𝐰𝐞 𝐫𝐞𝐚𝐥𝐥𝐲 𝐜𝐚𝐫𝐞 𝐭𝐡𝐞 𝐝𝐢𝐟𝐟𝐞𝐫𝐞𝐧𝐜𝐞?
Yes! For large datasets, it’s better to use the Count property instead of the Count() method whenever possible, because Count() still has the overhead of checking the type and calling the property.

❓ 𝐇𝐚𝐯𝐞 𝐲𝐨𝐮 𝐞𝐯𝐞𝐫 𝐟𝐚𝐜𝐞𝐝 𝐰𝐢𝐭𝐡 𝐬𝐮𝐜𝐡 𝐩𝐞𝐫𝐟𝐨𝐫𝐦𝐚𝐧𝐜𝐞 𝐢𝐬𝐬𝐮𝐞? 𝐒𝐡𝐚𝐫𝐞 𝐲𝐨𝐮𝐫 𝐞𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞.

🚀 𝐒𝐭𝐨𝐩 𝐫𝐞𝐩𝐞𝐚𝐭𝐢𝐧𝐠 @𝐦𝐞𝐝𝐢𝐚 𝐬𝐜𝐫𝐞𝐞𝐧! 𝐔𝐬𝐞 𝐒𝐚𝐬𝐬 𝐌𝐢𝐱𝐢𝐧𝐬 𝐭𝐨 𝐦𝐚𝐤𝐞 𝐲𝐨𝐮𝐫 𝐫𝐞𝐬𝐩𝐨𝐧𝐬𝐢𝐯𝐞 𝐂𝐒𝐒 𝐜𝐥𝐞𝐚𝐧𝐞𝐫 𝐚𝐧𝐝 𝐬𝐦𝐚𝐫𝐭𝐞𝐫.

Shirin Monzavi — Sat, 15 Nov 2025 04:41:26 +0000

𝐏𝐫𝐨𝐛𝐥𝐞𝐦?
Assume, you are styling a responsive web application. When styling for different screen sizes, you often need to write multiple @media queries. This can lead to repeating @media statements throughout your CSS file. How can we avoid it?

𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧?
Sass solves this problem by Mixin. Mixins allow you to define styles that can be re-used throughout your stylesheet.

𝐇𝐨𝐰?
💠 Install Sass → npm install sass.

💠Define a mixing named it screen-style with the argument of size screen and in the body use @content (take an entire block of styles).

💠Define a new mixin named it small-breakpoint and use name of previous mixin with @include (it will be included in the previous mixin).

💠Define the desired selector.

💠Use the small-breakpoint mixin with @include inside the selector.

💠Add the desired styles.

❓ 𝐇𝐚𝐯𝐞 𝐲𝐨𝐮 𝐞𝐯𝐞𝐫 𝐮𝐬𝐞 𝐌𝐢𝐱𝐢𝐧𝐬? 𝐈𝐟 𝐬𝐨, 𝐒𝐡𝐚𝐫𝐞 𝐲𝐨𝐮𝐫 𝐞𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞 𝐢𝐧 𝐭𝐡𝐞 𝐜𝐨𝐦𝐦𝐞𝐧𝐭.

hashtag#CSS hashtag#Sass hashtag#FrontendDevelopment hashtag#WebDevelopment hashtag#CleanCode

𝐖𝐡𝐚𝐭 𝐢𝐬 𝐕𝐚𝐥𝐮𝐞-𝐎𝐛𝐣𝐞𝐜𝐭 𝐚𝐧𝐝 𝐇𝐨𝐰 𝐭𝐨 𝐬𝐭𝐨𝐫𝐞 𝐢𝐭 𝐢𝐧 𝐄𝐅 𝐂𝐨𝐫𝐞?

Shirin Monzavi — Wed, 24 Sep 2025 05:20:14 +0000

⁉️ 𝐖𝐡𝐚𝐭?
A value object is an object that can be identified by the composition of its values. For instance, an address can be considered as a value object because the compositions of country/region, city, street defines it.

𝐈𝐦𝐩𝐨𝐫𝐭𝐚𝐧𝐭 𝐜𝐡𝐚𝐫𝐚𝐜𝐭𝐞𝐫𝐢𝐬𝐭𝐢𝐜𝐬 𝐨𝐟 𝐯𝐚𝐥𝐮𝐞 𝐨𝐛𝐣𝐞𝐜𝐭𝐬:
1- They do not have identity. (For example, two customers with the same name are not the same and they can be distinguished by their Ids. On the other hand, when two addresses are identical, they are the same.).

2- They are immutable. (The values of a value object must be immutable once the object is created. Therefore, when the object is created, you must provide the required values but must not allow them to change).

🌍 𝑹𝒆𝒂𝒍-𝑾𝒐𝒓𝒍𝒅 𝑺𝒄𝒆𝒏𝒂𝒓𝒊𝒐
Consider an Order aggregate root this aggregate root contains one entity named Order Item with an id since two order items with the same products are still different and a value object named address since two addresses with the same values are considered equal.

💻 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭 𝐕𝐚𝐥𝐮𝐞 𝐨𝐛𝐣𝐞𝐜𝐭𝐬 𝐢𝐧 𝐂#
You can have a value object base class that has basic utility methods like equality based on the comparison between all the attributes and other fundamental characteristics. Then each value object can inherit from the base class.

🗄 𝐇𝐨𝐰 𝐜𝐚𝐧 𝐰𝐞 𝐬𝐭𝐨𝐫𝐞 𝐯𝐚𝐥𝐮𝐞 𝐨𝐛𝐣𝐞𝐜𝐭𝐬 𝐢𝐧 𝐭𝐡𝐞 𝐝𝐚𝐭𝐚𝐛𝐚𝐬𝐞 𝐬𝐢𝐧𝐜𝐞 𝐭𝐡𝐞𝐲 𝐡𝐚𝐯𝐞 𝐧𝐨 𝐢𝐝𝐞𝐧𝐭𝐢𝐭𝐲?
The best way to store value objects with EF Core 2.0 and later is using owned entity type. An owned entity type allows you to map types that do not have identity. For implementing value objects, the entity should contain navigation of the value object and in configuration file owned entity should be defined.
For example, in Order entity the Address is a values object and it is implemented as an owned entity type within the owner entity.
By default, EF Core conventions name the columns for the properties of the owned entity type like EntityProperty_OwnedEntityProperty. Therefore, the properties of Address will appear in the Orders table with the names Address_Street, Address_City but you can customize with the Property().HasColumnName().

❓ 𝐇𝐨𝐰 𝐡𝐚𝐯𝐞 𝐲𝐨𝐮 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 𝐭𝐡𝐞 𝐯𝐚𝐥𝐮𝐞 𝐨𝐛𝐣𝐞𝐜𝐭𝐬 𝐛𝐞𝐟𝐨𝐫𝐞 𝐄𝐅 𝐂𝐨𝐫𝐞 2.0?

🚀 𝐈𝐎𝐩𝐭𝐢𝐨𝐧𝐬 𝐯𝐬 𝐈𝐎𝐩𝐭𝐢𝐨𝐧𝐬𝐒𝐧𝐚𝐩𝐬𝐡𝐨𝐭 𝐯𝐬 𝐈𝐎𝐩𝐭𝐢𝐨𝐧𝐬𝐌𝐨𝐧𝐢𝐭𝐨𝐫 𝐢𝐧 .𝐍𝐄𝐓 — 𝐖𝐡𝐚𝐭’𝐬 𝐭𝐡𝐞 𝐃𝐢𝐟𝐟𝐞𝐫𝐞𝐧𝐜𝐞?

Shirin Monzavi — Thu, 28 Aug 2025 09:31:39 +0000

⁉️ 𝐖𝐡𝐚𝐭 𝐢𝐬 𝐭𝐡𝐞 𝐎𝐩𝐭𝐢𝐨𝐧𝐬 𝐩𝐚𝐭𝐭𝐞𝐫𝐧?
You can represent related settings using classes, which gives you strong typing for those settings.

✨ Benefits:
By applying this pattern, your app follows two important software engineering principles:

🔒 𝐄𝐧𝐜𝐚𝐩𝐬𝐮𝐥𝐚𝐭𝐢𝐨𝐧 – services only depend on the settings they actually use.
🧩 𝐒𝐞𝐩𝐚𝐫𝐚𝐭𝐢𝐨𝐧 𝐨𝐟 𝐜𝐨𝐧𝐜𝐞𝐫𝐧𝐬 – configuration logic is separated from business logic.

⚡ 𝑶𝒑𝒕𝒊𝒐𝒏𝒔 𝑰𝒏𝒕𝒆𝒓𝒇𝒂𝒄𝒆𝒔 𝒊𝒏 .𝑵𝑬𝑻

𝐈𝐎𝐩𝐭𝐢𝐨𝐧𝐬
• Reads configuration once at startup.
• ❌ Doesn’t update if config changes while the app is running.
• 🟢 Registered as Singleton, can be injected anywhere.

𝐈𝐎𝐩𝐭𝐢𝐨𝐧𝐬𝐒𝐧𝐚𝐩𝐬𝐡𝐨𝐭
• Reads configuration fresh on every request.
• Useful for per-request updates (e.g., in web apps).
• 🟡 Registered as Scoped, so cannot be injected into Singletons.

𝐈𝐎𝐩𝐭𝐢𝐨𝐧𝐬𝐌𝐨𝐧𝐢𝐭𝐨𝐫
• Supports real-time updates without restarting the app.
• Can trigger callbacks when config changes.
• 🟢 Registered as Singleton, safe to inject anywhere.

💡** Quick Summary**
• IOptions → Static, simple, app startup only.
• IOptionsSnapshot → Per-request updates.
• IOptionsMonitor → Real-time updates with change notifications.

❓ Which one have you used the most in your projects?

DotNet #DotNetCore #AspNetCore #DotNetDeveloper #CSharp #DotNetTips

🚀𝐁𝐨𝐨𝐬𝐭 𝐏𝐞𝐫𝐟𝐨𝐫𝐦𝐚𝐧𝐜𝐞 & 𝐒𝐞𝐜𝐮𝐫𝐢𝐭𝐲 𝐰𝐢𝐭𝐡 𝐭𝐡𝐞 𝐏𝐫𝐨𝐱𝐲 𝐏𝐚𝐭𝐭𝐞𝐫𝐧🚀

Shirin Monzavi — Mon, 11 Aug 2025 15:30:09 +0000

⁉️ 𝐌𝐨𝐭𝐢𝐯𝐚𝐭𝐢𝐨𝐧
The Proxy pattern belongs to the structural category and provides a surrogate or placeholder for another object to control access to it. It is also known as a Surrogate.

🌍 𝐑𝐞𝐚𝐥-𝐖𝐨𝐫𝐥𝐝 𝐒𝐜𝐞𝐧𝐚𝐫𝐢𝐨
Imagine we are building a document editor that embeds graphical objects in documents. Creating some graphical objects, like large raster images, is expensive. However, opening a document should be fast, so we want to avoid creating all expensive objects immediately.
These requirements suggest creating expensive objects on demand. So, what should we put in place of the image initially?

🎯 𝑺𝒐𝒍𝒖𝒕𝒊𝒐𝒏 — 𝑷𝒓𝒐𝒙𝒚 𝑷𝒂𝒕𝒕𝒆𝒓𝒏
The solution is to use another object, an image proxy, that acts like the real image. The proxy behaves just like the image and takes care of instantiating it only when needed. The image proxy creates the real image only when the document editor requests it to display it. After creation, the proxy forwards all subsequent requests directly to the real image. Therefore, the proxy keeps a reference to the real image once it’s created.

🧠 𝑾𝒉𝒆𝒏 𝒕𝒐 𝑨𝒑𝒑𝒍𝒚:
𝐑𝐞𝐦𝐨𝐭𝐞 𝐩𝐫𝐨𝐱𝐲: When the real object is located elsewhere (over the network or on a different machine), communicating directly can be complex. A proxy can handle communication instead.
𝐕𝐢𝐫𝐭𝐮𝐚𝐥 𝐩𝐫𝐨𝐱𝐲: When creating an object is expensive, a proxy can delay creation until it’s actually needed (lazy loading). See the real-world example above.
𝐏𝐫𝐨𝐭𝐞𝐜𝐭𝐢𝐨𝐧 𝐩𝐫𝐨𝐱𝐲: Controls access to the original object, enforcing access rights.
𝐒𝐦𝐚𝐫𝐭 𝐫𝐞𝐟𝐞𝐫𝐞𝐧𝐜𝐞: Replaces a simple reference but adds extra behavior each time the object is accessed (e.g., counting references).

💎 𝐑𝐞𝐥𝐚𝐭𝐞𝐝 𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬:
𝐀𝐝𝐚𝐩𝐭𝐞𝐫: Provides a different interface for an object, while a proxy provides the same interface as its subject.
𝐃𝐞𝐜𝐨𝐫𝐚𝐭𝐨𝐫: Similar in structure to a proxy but adds responsibilities to an object, whereas a proxy controls access.

📂 𝑪𝒐𝒅𝒆 𝑬𝒙𝒂𝒎𝒑𝒍𝒆:
👉 𝐆𝐢𝐭𝐇𝐮𝐛 - https://github.com/shirin-monzavi/ProxyDesignPatternSample/tree/master

❓ Have you ever used the Proxy Pattern in your projects? Share your experience!

Memory management with Flyweight Design Pattern

Shirin Monzavi — Sat, 28 Jun 2025 17:00:50 +0000

🚀 𝐒𝐦𝐚𝐫𝐭 𝐌𝐞𝐦𝐨𝐫𝐲 𝐌𝐚𝐧𝐚𝐠𝐞𝐦𝐞𝐧𝐭 𝐰𝐢𝐭𝐡 𝐭𝐡𝐞 𝐅𝐥𝐲𝐰𝐞𝐢𝐠𝐡𝐭 𝐏𝐚𝐭𝐭𝐞𝐫𝐧 🚀

⁉️ 𝑴𝒐𝒕𝒊𝒗𝒂𝒕𝒊𝒐𝒏
The intent of flyweight is to share an object instead of having many objects.

🌍 𝑹𝒆𝒂𝒍-𝑾𝒐𝒓𝒍𝒅 𝑺𝒄𝒆𝒏𝒂𝒓𝒊𝒐
Assume you want to design a document editor, and this editor contains:
• 📊 Tables
• 🖼️ Figures
• 🔤 Characters

In object-oriented design, we usually represent these entities as objects.
⚠️ But here's the problem:
Documents can contain thousands of characters, and creating a separate object for each one leads to:
🔻 Too many objects
🔻 High memory usage
🔻 Unacceptable run-time overhead

💡 This is where the Flyweight Pattern becomes useful — it helps avoid the cost of creating tons of similar objects by sharing them efficiently.

🎯 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 — 𝐅𝐋𝐘𝐖𝐄𝐈𝐆𝐇𝐓 𝐏𝐚𝐭𝐭𝐞𝐫𝐧
Flyweight is an object which can be shared in multiple contexts simultaneously.

🔑 Flyweights cannot guess the context they operate in, so the client must pass the extrinsic state when needed.

🧠 The key idea lies in the difference between:
🔸 Intrinsic state: stored inside the flyweight — it's independent of the context and sharable.
🔸 Extrinsic state: provided by the client — it's context-dependent and cannot be shared.

📌 Example:
The character 'A' in a document is an intrinsic part — the alphabet symbol stays the same.
But the font size, color, and position are extrinsic, as they vary by context.

🧠 𝐀𝐩𝐩𝐥𝐲 𝐅𝐥𝐲𝐖𝐞𝐢𝐠𝐡𝐭 𝐰𝐡𝐞𝐧 𝐚𝐥𝐥 𝐨𝐟 𝐭𝐡𝐞 𝐟𝐨𝐥𝐥𝐨𝐰𝐢𝐧𝐠 𝐚𝐫𝐞 𝐭𝐫𝐮𝐞:
✅ A program uses a lot of objects.
✅ Storage costs are high due to the sheer quantity of objects.
✅ Most object state can be made extrinsic.
✅ Removing extrinsic state allows many objects to be replaced with fewer shared ones.
✅ The application does not rely on object identity. Identity check may return true even if the instances of flyweight are different conceptually. (e.g., font, size, color).

💎 𝑹𝒆𝒍𝒂𝒕𝒆𝒅 𝑷𝒂𝒕𝒕𝒆𝒓𝒏𝒔:
◾ 𝐂𝐨𝐦𝐩𝐨𝐬𝐢𝐭𝐞: The Flyweight pattern is often combined with the Composite pattern to implement a logically hierarchical structure in terms of a directed-acyclic graph with shared leaf nodes.

◾It's often best to implement 𝐒𝐭𝐚𝐭𝐞 and 𝐒𝐭𝐫𝐚𝐭𝐞𝐠𝐲 objects as flyweights.

📂 𝐂𝐨𝐝𝐞 𝐄𝐱𝐚𝐦𝐩𝐥𝐞
👉 GitHub - https://github.com/shirin-monzavi/FlyWeightDesignPattern

❓Have you ever used the 𝐅𝐋𝐘𝐖𝐄𝐈𝐆𝐇𝐓 Pattern in your projects?

When to use Facade Design Pattern?

Shirin Monzavi — Mon, 02 Jun 2025 10:37:41 +0000

🚀When to use Facade Design Pattern?🚀

⁉️ 𝑴𝒐𝒕𝒊𝒗𝒂𝒕𝒊𝒐𝒏
It defines a single interface for a set of interfaces in a subsystem which leads to ease of use for the clients.

🌍 𝑹𝒆𝒂𝒍-𝑾𝒐𝒓𝒍𝒅 𝑺𝒄𝒆𝒏𝒂𝒓𝒊𝒐
Assume, a programming environment provides functionalities such as Scanner, Parser, ProgramNode, and ProgramNodeBuilder that implement the compiler. Some applications might need to access these classes directly, but most clients need to use just compile code. So, for them the low-level interface, leads complexity.

🎯 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 — 𝐅𝐀𝐂𝐀𝐃𝐄 𝐏𝐚𝐭𝐭𝐞𝐫𝐧
Façade defines a unified interface for the compiler’s functionality to shield clients from those classes.
The compiler façade makes life easier for most programmers without hiding the lower-level functionality from whom that need it.

🧠 𝐖𝐡𝐞𝐧 𝐭𝐨 𝐔𝐬𝐞
✔️ Providing a simple interface from a complex subsystem.
✔️ Decoupling the subsystems from clients and other systems.
✔️ Layering your subsystems.

💎 𝑹𝒆𝒍𝒂𝒕𝒆𝒅 𝑷𝒂𝒕𝒕𝒆𝒓𝒏𝒔:
◾𝐀𝐛𝐬𝐭𝐫𝐚𝐜𝐭 𝐅𝐚𝐜𝐭𝐨𝐫𝐲: be used with Facade to provide an interface for creating subsystem objects in a subsystem-independent way. Abstract Factory can also be used as an alternative to Facade to hide platform-specific classes.

📂 𝐂𝐨𝐝𝐞 𝐄𝐱𝐚𝐦𝐩𝐥𝐞
👉 GitHub - https://lnkd.in/dUrWeR46

❓Have you ever used the 𝐅𝐀𝐂𝐀𝐃𝐄 Pattern in your projects?

hashtag#DesignPatterns hashtag#SoftwareEngineering hashtag#DevTips hashtag#FacadePattern

What is Decorator Design Pattern?

Shirin Monzavi — Mon, 26 May 2025 09:06:13 +0000

⁉️ 𝑴𝒐𝒕𝒊𝒗𝒂𝒕𝒊𝒐𝒏
Have you ever tried to add responsibility to an object dynamically? Decorator provides a flexible alternative to subclassing. It is known as wrapper.

🌍 𝑹𝒆𝒂𝒍-𝑾𝒐𝒓𝒍𝒅 𝑺𝒄𝒆𝒏𝒂𝒓𝒊𝒐
Imagine, there is a graphical component that lets you add properties such as: border, scroll bar, and so forth. One way to implement it is using inheritance, but it is not flexible. Since, the border is added statically, and a client cannot control how and when to decorate a component with a border. How can we add the border in a flexible way?

🎯 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 — 𝐃𝐄𝐂𝐎𝐑𝐀𝐓𝐎𝐑 𝐏𝐚𝐭𝐭𝐞𝐫𝐧
Decorator encloses the component in another object that adds the border. The decorator conforms to the interface of the component it decorates. So, its presence is transparent to clients. The decorator forwards the request to the component and it does some actions such as adding a boarder before or after forwarding.

🧠 𝐖𝐡𝐞𝐧 𝐭𝐨 𝐔𝐬𝐞
✔️Add a functionality to an object dynamically and transparently with zero effects for other objects.
✔️ For functionalities which can be removed.
✔️When we want to extend a functionality with subclassing, but it is impossible, due to the explosion of subclasses.

💎 𝑹𝒆𝒍𝒂𝒕𝒆𝒅 𝑷𝒂𝒕𝒕𝒆𝒓𝒏𝒔:
◾ 𝐀𝐝𝐚𝐩𝐭𝐞𝐫: the adapter grants an object a new interface, but the decorator changes the responsibilities of an object.

◾𝐂𝐨𝐦𝐩𝐨𝐬𝐢𝐭𝐞: we can consider the decorator as a decadent version of composite since it has only one component.

◾𝐒𝐭𝐫𝐚𝐭𝐞𝐠𝐲: the decorator changes the skin of an object while the strategy modifies mechanism.

📂 𝐂𝐨𝐝𝐞 𝐄𝐱𝐚𝐦𝐩𝐥𝐞
👉 GitHub - https://lnkd.in/dv_YvFTd

❓Have you ever used the 𝐃𝐄𝐂𝐎𝐑𝐀𝐓𝐎𝐑 Pattern in your projects?

Composite Design Pattern In C#

Shirin Monzavi — Fri, 09 May 2025 07:45:13 +0000

🚀 Design Pattern

⁉️ 𝑴𝒐𝒕𝒊𝒗𝒂𝒕𝒊𝒐𝒏
Compose objects into tree structures to represent part or whole of hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.

🌍 𝑹𝒆𝒂𝒍-𝑾𝒐𝒓𝒍𝒅 𝑺𝒄𝒆𝒏𝒂𝒓𝒊𝒐
Imagine you're building a graphical editor. Users can create basic shapes like Text, Circle, etc., and combine them into complex images.
A basic solution might involve one class for simple objects and another for containers. But this forces clients to handle each differently, increasing complexity.

🎯 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 — 𝐂𝐨𝐦𝐩𝐨𝐬𝐢𝐭𝐞 𝐏𝐚𝐭𝐭𝐞𝐫𝐧
Composite pattern helps us to recursive composition so that clients are not required to make this distinction. This pattern has an abstract class for both primitives and their containers.
For instance, in the graphics system this abstract named Graphic which declares operation like Draw for graphical objects. It also declares operations that all composite objects share, such as Get Child, Add, Remove.
The Picture class defines a list of graphic objects and implements draw to call draw on its children. In addition, the picture implements child-related operations. Since the picture interface inherits from the Graphic interface, picture objects can compose other pictures recursively.

🧠 𝐖𝐡𝐞𝐧 𝐭𝐨 𝐔𝐬𝐞
✔️ When individual objects and object groups should be handled identically.
✔️ When tree structures or recursive hierarchies are involved.

💎 𝑹𝒆𝒍𝒂𝒕𝒆𝒅 𝑷𝒂𝒕𝒕𝒆𝒓𝒏𝒔
🔁 Chain of Responsibility often uses parent references.
🎨 Decorator works well with Composite to extend behavior.
🧬 Flyweight can reduce memory usage but removes parent references.
🔍 Iterator helps traverse composite structures.
🧭 Visitor centralizes operations across Composite and Leaf classes.

📂 𝑪𝒐𝒅𝒆 𝑬𝒙𝒂𝒎𝒑𝒍𝒆
👉 GitHub - https://lnkd.in/dy9h_VuA

💬 𝐘𝐨𝐮𝐫 𝐓𝐮𝐫𝐧!
❓𝐇𝐚𝐯𝐞 𝐲𝐨𝐮 𝐞𝐯𝐞𝐫 𝐮𝐬𝐞𝐝 𝐭𝐡𝐞 𝐂𝐨𝐦𝐩𝐨𝐬𝐢𝐭𝐞 𝐏𝐚𝐭𝐭𝐞𝐫𝐧 𝐢𝐧 𝐲𝐨𝐮𝐫 𝐩𝐫𝐨𝐣𝐞𝐜𝐭𝐬?

hashtag#DesignPatterns hashtag#SoftwareEngineering hashtag#DevTips hashtag#CompositePattern

What is Bridge Design Pattern?

Shirin Monzavi — Sat, 26 Apr 2025 17:34:37 +0000

🚀All things you should know about bridge design pattern

⁉️ Motivation
Decouple an abstraction from its implementation so that both can evolve independently. It belongs to the structural category.

🌍 Real-World Scenario
When an abstraction can have multiple implementations, the typical approach is inheritance. But this leads to some issues.
Let’s say we have an abstract class Window, with two implementations: XWindow and PMWindow. If we use inheritance and want to add a new type like IconWindow, we’ll need to create XIconWindow and PMIconWindow.
This leads to:

1️⃣ Class explosion – For every new window type, we must implement it for each platform.

2️⃣ Tight coupling – The client is forced to choose a concrete platform (XWindow or PMWindow), tying the code to a specific implementation.

🎯 Solution — Bridge Pattern
The Bridge pattern solves this by splitting the abstraction (Window, IconWindow, TransientWindow, etc.) from the implementation (WindowImp, XWindowImp, PMWindowImp, etc.).
💡 The abstraction holds a reference to the implementation, and they communicate through a defined interface. This bridges the two hierarchies, enabling independent evolution and better flexibility.

💎 Related Patterns
• Abstract Factory can help create and configure a particular Bridge.
• Adapter lets unrelated classes work together, but it's applied after design.
• Bridge is a design-time decision to decouple abstraction from implementation.

📂** Code Example**
See it in action:
👉 GitHub - https://github.com/shirin-monzavi/BridgeDesignPatternSample

💬 Your Turn!
❓Have you ever used the Bridge Pattern in your projects?

Adapter Design Pattern

Shirin Monzavi — Thu, 10 Apr 2025 17:57:12 +0000

𝐓𝐢𝐭𝐥𝐞🔌𝐀𝐝𝐚𝐩𝐭𝐞𝐫 𝐃𝐞𝐬𝐢𝐠𝐧 𝐏𝐚𝐭𝐭𝐞𝐫𝐧

⁉️ 𝐈𝐧𝐭𝐞𝐧𝐭
Allows classes work together although they have incompatible interfaces.

🤯𝐏𝐫𝐨𝐛𝐥𝐞𝐦
Have you ever tried to integrate two existing system…but they just don’t fit together?

🌏 𝐑𝐞𝐚𝐥-𝐖𝐨𝐫𝐥𝐝 𝐒𝐜𝐞𝐧𝐚𝐫𝐢𝐨
For example a drawing editor provides users actions such as: draw and arrange of graphical elements (lines, text, etc.). This editor provides an abstract class named Shape. Classes for elementary shapes like LineShape and PolygonShape are easy to implement, but TextShape is not because it displays and edits text. Meanwhile, there is a toolkit class which already implements displaying and editing text named TextView, but it was not designed to work with Shape classes. Therefore, we cannot use TextView and Shape interchangeably. How can we cope with this issue?

🎯 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 — 𝐀𝐝𝐚𝐩𝐭𝐞𝐫 𝐏𝐚𝐭𝐭𝐞𝐫𝐧
We can define TextShape so that it adapts the TextView to Shape. We can do it in one of two ways:
1️⃣𝐈𝐧𝐡𝐞𝐫𝐢𝐭𝐚𝐧𝐜𝐞
2️⃣𝐂𝐨𝐦𝐩𝐨𝐬𝐢𝐭𝐢𝐨𝐧

💎𝐑𝐞𝐥𝐚𝐭𝐞𝐝 𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬
Bridge has a structure similar to an object adapter, but Bridge has a different intent: It is meant to separate an interface from its implementation so that they can be varied independently. An Adapter is meant to change the interface of an existing object. Decorator enhances another object without changing its interface. A decorator is thus more transparent to the application than an adapter is. As a consequence, Decorator supports recursive composition, which isn't possible with pure adapters.

📂 𝐂𝐨𝐝𝐞 𝐄𝐱𝐚𝐦𝐩𝐥𝐞
See it in action:
👉 GitHub - (https://github.com/shirin-monzavi/AdapterSample)

❓𝐖𝐡𝐢𝐜𝐡 𝐝𝐞𝐬𝐢𝐠𝐧 𝐩𝐚𝐭𝐭𝐞𝐫𝐧 𝐝𝐨 𝐲𝐨𝐮 𝐬𝐭𝐫𝐮𝐠𝐠𝐥𝐞 𝐰𝐢𝐭𝐡 𝐭𝐡𝐞 𝐦𝐨𝐬𝐭?

👇 I’d love to hear your thoughts!