🧠 Mastering 5 Design Patterns in C# - Part 4

✨ Introduction

Continuing our deep dive into design patterns, this third part explores 5 additional patterns that enhance scalability, modularity, and dependency control. Still using the notification system as our context, we’ll cover:

• Flyweight

• Prototype

• Visitor

• Interpreter

• Service Locator

---

🪶 1. Flyweight – Memory Optimization

✅ Intent

Minimize memory usage by sharing common data between similar objects.

🎯 Purpose

Useful when your system creates many similar objects, like notifications with repeated styles.

🧩 Code

public class NotificationStyle
{
    public string Font { get; set; }
    public string Color { get; set; }
}

public class StyleFactory
{
    private readonly Dictionary<string, NotificationStyle> _styles = new();

    public NotificationStyle GetStyle(string key)
    {
        if (!_styles.ContainsKey(key))
        {
            _styles[key] = new NotificationStyle { Font = "Arial", Color = key };
        }
        return _styles[key];
    }
}

🧠 Explanation

• StyleFactory shares style instances to save memory.

👍 Pros

• Reduces memory footprint.

• Improves performance.

👎 Cons

• Adds complexity.

• Harder with mutable objects.

---

🧬 2. Prototype – Object Cloning

✅ Intent

Create new objects by copying an existing instance.

🎯 Purpose

Ideal when object creation is expensive or complex, and you want to duplicate with slight variations.

🧩 Code

public class Notification : ICloneable
{
    public string Title { get; set; }
    public string Message { get; set; }

    public object Clone()
    {
        return MemberwiseClone();
    }
}

🧠 Explanation

• ICloneable allows quick duplication of notifications.

👍 Pros

• Fast object creation.

• Avoids repetitive setup.

👎 Cons

• May result in shallow copies.

• Tricky with deep object graphs.

---

🧭 3. Visitor – External Operations

✅ Intent

Add operations to objects without modifying their classes.

🎯 Purpose

Great for performing multiple actions on a structure of objects, like exporting notifications.

🧩 Code

public interface IVisitable
{
    void Accept(INotificationVisitor visitor);
}

public interface INotificationVisitor
{
    void Visit(Notification notification);
}

public class Notification : IVisitable
{
    public string Message { get; set; }

    public void Accept(INotificationVisitor visitor)
    {
        visitor.Visit(this);
    }
}

public class ExportVisitor : INotificationVisitor
{
    public void Visit(Notification notification)
    {
        Console.WriteLine($"Exporting: {notification.Message}");
    }
}

🧠 Explanation

• Visitor separates export logic from the core class.

👍 Pros

• Highly extensible.

• Keeps classes clean.

👎 Cons

• Adds complexity.

• Harder with deep hierarchies.

---

🧮 4. Interpreter – Custom Language

✅ Intent

Interpret sentences in a custom language.

🎯 Purpose

Useful for custom notification commands, like filters or rules.

🧩 Code

public interface IExpression
{
    bool Interpret(string context);
}

public class ContainsExpression : IExpression
{
    private readonly string _keyword;

    public ContainsExpression(string keyword)
    {
        _keyword = keyword;
    }

    public bool Interpret(string context)
    {
        return context.Contains(_keyword);
    }
}

🧠 Explanation

• ContainsExpression checks if a message contains a keyword.

👍 Pros

• Flexible for rule engines.

• Easy to extend.

👎 Cons

• Can be slow.

• Hard to scale for complex grammars.

---

🧭 5. Service Locator – Centralized Access

✅ Intent

Provide a way to locate services without direct dependencies.

🎯 Purpose

Ideal for managing dependencies like notification channels.

🧩 Code

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

public class EmailService : INotificationService
{
    public void Send(string message) => Console.WriteLine($"Email: {message}");
}

public class ServiceLocator
{
    private static readonly Dictionary<string, INotificationService> _services = new();

    public static void Register(string key, INotificationService service)
    {
        _services[key] = service;
    }

    public static INotificationService GetService(string key)
    {
        return _services[key];
    }
}

🧠 Explanation

• ServiceLocator centralizes access to notification services.

👍 Pros

• Reduces coupling.

• Easy to swap implementations.

👎 Cons

• Can obscure dependencies.

• Less transparent than dependency injection.

---

🧾 Conclusion

These five patterns expand your toolkit for building scalable, maintainable systems:

• Flyweight saves memory.

• Prototype enables cloning.

• Visitor separates operations.

• Interpreter supports custom rules.

• Service Locator centralizes dependencies.

#CSharp #DesignPatterns #DotNet #SoftwareEngineering #CleanArchitecture #BackendDev #CodeQuality #ProgrammingTips #Flyweight #Protoype #Visitor #Interpreter #ServiceLocator