🧠 Mastering 5 Design Patterns in C# - Part 2

✨ Introduction

Continuing our exploration of design patterns in C#, this article presents 5 additional patterns using the same notification system context. These patterns help solve different architectural challenges and improve code flexibility, scalability, and maintainability.

The patterns covered here are:

• Adapter

• Command

• Proxy

• Composite

• Template Method

---

🔌 1. Adapter – Bridging Interfaces

✅ Intent

Convert the interface of a class into another interface clients expect.

🎯 Purpose

Use when you need to integrate incompatible interfaces without modifying existing code — especially useful when working with third-party libraries or legacy systems.

🧩 Code

public class LegacyNotifier
{
    public void LegacySend(string msg)
    {
        Console.WriteLine($"Legacy system sent: {msg}");
    }
}

public interface INotifier
{
    void Send(string message);
}

public class NotifierAdapter : INotifier
{
    private readonly LegacyNotifier _legacy;

    public NotifierAdapter(LegacyNotifier legacy)
    {
        _legacy = legacy;
    }

    public void Send(string message)
    {
        _legacy.LegacySend(message);
    }
}

🧠 Explanation

• LegacyNotifier → Old system with incompatible method.

• INotifier → Expected interface.

• NotifierAdapter → Bridges the gap between old and new.

👍 Pros

• Promotes reuse of legacy code.

• Decouples systems.

👎 Cons

• Adds extra layer of abstraction.

• Can become messy with many adapters.

---

🧾 2. Command – Encapsulating Actions

✅ Intent

Encapsulate a request as an object, allowing parameterization and queuing of requests.

🎯 Purpose

Use when you need to queue, log, or undo operations, or when actions should be executed later or remotely.

🧩 Code

public interface ICommand
{
    void Execute();
}

public class EmailCommand : ICommand
{
    private readonly string _message;

    public EmailCommand(string message)
    {
        _message = message;
    }

    public void Execute()
    {
        Console.WriteLine($"Email command executed: {_message}");
    }
}

public class CommandInvoker
{
    private readonly List<ICommand> _commands = new();

    public void AddCommand(ICommand command) => _commands.Add(command);

    public void Run()
    {
        foreach (var cmd in _commands)
            cmd.Execute();
    }
}

🧠 Explanation

• ICommand → Interface for commands.

• EmailCommand → Encapsulates email sending.

• CommandInvoker → Stores and executes commands.

👍 Pros

• Enables undo/redo.

• Decouples sender from receiver.

👎 Cons

• Requires many small classes.

• Can be overkill for simple tasks.

---

🧿 3. Proxy – Controlled Access

✅ Intent

Provide a surrogate or placeholder for another object to control access to it.

🎯 Purpose

Use when you need to add access control, lazy loading, or logging without changing the original object.

🧩 Code

public interface INotifier
{
    void Send(string message);
}

public class RealNotifier : INotifier
{
    public void Send(string message)
    {
        Console.WriteLine($"Real notifier: {message}");
    }
}

public class NotifierProxy : INotifier
{
    private readonly RealNotifier _realNotifier = new();

    public void Send(string message)
    {
        Console.WriteLine("Proxy: Checking permissions...");
        _realNotifier.Send(message);
    }
}

🧠 Explanation

• RealNotifier → Actual implementation.

• NotifierProxy → Adds control before delegating.

👍 Pros

• Adds security, logging, or caching.

• Transparent to client.

👎 Cons

• Adds complexity.

• Can introduce performance overhead.

---

🌳 4. Composite – Hierarchical Structures

✅ Intent

Compose objects into tree structures to represent part-whole hierarchies.

🎯 Purpose

Use when you need to treat individual objects and groups uniformly, such as nested notifications or UI components.

🧩 Code

public interface INotifier
{
    void Send(string message);
}

public class SingleNotifier : INotifier
{
    public void Send(string message)
    {
        Console.WriteLine($"Single: {message}");
    }
}

public class CompositeNotifier : INotifier
{
    private readonly List<INotifier> _notifiers = new();

    public void Add(INotifier notifier) => _notifiers.Add(notifier);

    public void Send(string message)
    {
        foreach (var notifier in _notifiers)
            notifier.Send(message);
    }
}

🧠 Explanation

• SingleNotifier → Individual notification.

• CompositeNotifier → Group of notifiers treated as one.

👍 Pros

• Simplifies hierarchical structures.

• Uniform treatment of objects.

👎 Cons

• Can be hard to manage deep trees.

• Debugging can be tricky.

---

🧬 5. Template Method – Algorithm Skeleton

✅ Intent

Define the skeleton of an algorithm, deferring steps to subclasses.

🎯 Purpose

Use when you have a fixed process with customizable steps, like sending notifications with pre- and post-processing.

🧩 Code

public abstract class NotificationTemplate
{
    public void Send(string message)
    {
        PreSend();
        DoSend(message);
        PostSend();
    }

    protected virtual void PreSend() => Console.WriteLine("Preparing to send...");
    protected abstract void DoSend(string message);
    protected virtual void PostSend() => Console.WriteLine("Finished sending.");
}

public class EmailNotification : NotificationTemplate
{
    protected override void DoSend(string message)
    {
        Console.WriteLine($"Email sent: {message}");
    }
}

🧠 Explanation

• NotificationTemplate → Defines the algorithm structure.

• EmailNotification → Implements the core step.

👍 Pros

• Promotes code reuse.

• Enforces consistent process.

👎 Cons

• Inflexible if steps vary too much.

• Can lead to deep inheritance chains.

---

🧾 Conclusion

These five additional design patterns offer powerful tools for structuring your C# applications:

• Adapter bridges incompatible interfaces.

• Command encapsulates actions for flexibility.

• Proxy controls access and adds behavior.

• Composite handles hierarchical structures.

• Template Method enforces consistent workflows.

Using the same notification example across all patterns helps highlight their unique strengths and trade-offs

#CSharp #DesignPatterns #DotNet #SoftwareEngineering #CleanArchitecture #BackendDev #CodeQuality #ProgrammingTips #Adapter #Command #Proxy #Composite #TemplateMethod #