🧠 Mastering 5 Design Patterns in C# - Part 3

✨ Introduction

Continuing our deep dive into design patterns, we now arrive at the final part of the series. In this concluding section, we’ll explore 5 additional patterns that bring advanced flexibility and control to software architecture. Still using the same notification system context, we’ll examine

• Chain of Responsibility

• Mediator

• State

• Builder

• Memento

---

🔗 1. Chain of Responsibility – Sequential Processing

✅ Intent

Pass a request along a chain of handlers until one handles it.

🎯 Purpose

Use when you need to process requests through a sequence of steps, where each handler decides whether to act or pass it along.

🧩 Code

public abstract class NotificationHandler
{
    protected NotificationHandler _next;

    public void SetNext(NotificationHandler next) => _next = next;

    public abstract void Handle(string message);
}

public class EmailHandler : NotificationHandler
{
    public override void Handle(string message)
    {
        if (message.Contains("email"))
            Console.WriteLine($"Handled by Email: {message}");
        else
            _next?.Handle(message);
    }
}

public class SmsHandler : NotificationHandler
{
    public override void Handle(string message)
    {
        if (message.Contains("sms"))
            Console.WriteLine($"Handled by SMS: {message}");
        else
            _next?.Handle(message);
    }
}

🧠 Explanation

• NotificationHandler → Base handler with chaining logic.

• EmailHandler and SmsHandler → Handle specific message types.

👍 Pros

• Flexible and extensible.

• Decouples sender from receiver.

👎 Cons

• Hard to trace flow.

• Handlers must be carefully ordered.

---

🧭 2. Mediator – Centralized Communication

✅ Intent

Define an object that encapsulates how a set of objects interact.

🎯 Purpose

Use when you want to reduce direct dependencies between objects, centralizing communication logic.

🧩 Code

public interface IMediator
{
    void Notify(object sender, string message);
}

public class NotificationMediator : IMediator
{
    public void Notify(object sender, string message)
    {
        Console.WriteLine($"Mediator received: {message}");
    }
}

public class EmailComponent
{
    private readonly IMediator _mediator;

    public EmailComponent(IMediator mediator)
    {
        _mediator = mediator;
    }

    public void Send(string message)
    {
        _mediator.Notify(this, $"Email: {message}");
    }
}

🧠 Explanation

• IMediator → Interface for communication.

• NotificationMediator → Central hub.

• EmailComponent → Sends via mediator.

👍 Pros

• Reduces coupling.

• Centralizes logic.

👎 Cons

• Mediator can become complex.

• Harder to debug interactions.

---

🎭 3. State – Dynamic Behavior

✅ Intent

Allow an object to alter its behavior when its internal state changes.

🎯 Purpose

Use when an object’s behavior depends on its state, and you want to avoid complex conditionals.

🧩 Code

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

public class ActiveState : INotificationState
{
    public void Send(string message)
    {
        Console.WriteLine($"Active: {message}");
    }
}

public class DisabledState : INotificationState
{
    public void Send(string message)
    {
        Console.WriteLine("Notifications are disabled.");
    }
}

public class NotificationContext
{
    private INotificationState _state;

    public NotificationContext(INotificationState state)
    {
        _state = state;
    }

    public void SetState(INotificationState state) => _state = state;

    public void Send(string message) => _state.Send(message);
}

🧠 Explanation

• INotificationState → Interface for states.

• ActiveState and DisabledState → Define behavior.

• NotificationContext → Switches states dynamically.

👍 Pros

• Cleaner state management.

• Avoids conditionals.

👎 Cons

• Requires multiple classes.

• Can be overkill for simple logic.

---

🧱 4. Builder – Step-by-Step Construction

✅ Intent

Separate the construction of a complex object from its representation.

🎯 Purpose

Use when you need to build complex objects step by step, especially when there are many optional parts.

🧩 Code

public class Notification
{
    public string Title { get; set; }
    public string Body { get; set; }
    public bool SendEmail { get; set; }
    public bool SendSms { get; set; }

    public void Show()
    {
        Console.WriteLine($"Title: {Title}, Body: {Body}, Email: {SendEmail}, SMS: {SendSms}");
    }
}

public class NotificationBuilder
{
    private readonly Notification _notification = new();

    public NotificationBuilder SetTitle(string title)
    {
        _notification.Title = title;
        return this;
    }

    public NotificationBuilder SetBody(string body)
    {
        _notification.Body = body;
        return this;
    }

    public NotificationBuilder EnableEmail()
    {
        _notification.SendEmail = true;
        return this;
    }

    public NotificationBuilder EnableSms()
    {
        _notification.SendSms = true;
        return this;
    }

    public Notification Build() => _notification;
}

🧠 Explanation

• Notification → Final object.

• NotificationBuilder → Builds it step by step.

👍 Pros

• Clear and readable construction.

• Flexible for optional parameters.

👎 Cons

• Requires extra class.

• Can be verbose for simple objects.

---

🧠 5. Memento – State Snapshot

✅ Intent

Capture and restore an object’s internal state without violating encapsulation.

🎯 Purpose

Use when you need to implement undo/redo functionality or preserve historical states.

🧩 Code

public class NotificationMemento
{
    public string Message { get; }

    public NotificationMemento(string message)
    {
        Message = message;
    }
}

public class NotificationOriginator
{
    private string _message;

    public void SetMessage(string message)
    {
        _message = message;
        Console.WriteLine($"Current message: {_message}");
    }

    public NotificationMemento Save() => new(_message);

    public void Restore(NotificationMemento memento)
    {
        _message = memento.Message;
        Console.WriteLine($"Restored message: {_message}");
    }
}

🧠 Explanation

• NotificationMemento → Stores state.

• NotificationOriginator → Saves and restores state.

👍 Pros

• Enables undo/redo.

• Preserves encapsulation.

👎 Cons

• Can consume memory.

• Requires careful state management.

---

🧾 Conclusion

These final five design patterns offer powerful tools for managing complexity and behavior:

• Chain of Responsibility handles requests in sequence.

• Mediator centralizes communication.

• State enables dynamic behavior.

• Builder simplifies object construction.

• Memento preserves and restores state.

Together with the previous ten patterns, you now have a solid foundation for building scalable, maintainable C# applications.

#CSharp #DesignPatterns #DotNet #SoftwareDesign #CodeArchitecture #BackendEngineering #CleanCode #DevTips #ChainOfResponsability #Mediator #State #Builder #Memento #Development #Developer