🧠 Mastering 5 Design Patterns in C# - Parte 6

✨ Introduction

These patterns focus on business logic composition, fault tolerance, and efficient processing. None of the previously listed patterns are repeated. Let’s dive into:

• Specification

• Event Sourcing

• Throttling

• Retry

• Pipeline

---

📋 1. Specification – Composable Business Rules

✅ Intent

Encapsulate business rules into reusable, combinable objects.

🎯 Use When

You need complex, reusable validation logic, such as deciding whether a notification should be sent.

🧩 Code

public interface ISpecification<T>
{
    bool IsSatisfiedBy(T item);
}

public class LengthSpecification : ISpecification<string>
{
    public bool IsSatisfiedBy(string message) => message.Length <= 140;
}

public class NoSpamSpecification : ISpecification<string>
{
    public bool IsSatisfiedBy(string message) => !message.Contains("spam");
}

public class AndSpecification<T> : ISpecification<T>
{
    private readonly ISpecification<T> _a, _b;

    public AndSpecification(ISpecification<T> a, ISpecification<T> b)
    {
        _a = a;
        _b = b;
    }

    public bool IsSatisfiedBy(T item) => _a.IsSatisfiedBy(item) && _b.IsSatisfiedBy(item);
}

✅ Explanation

Each rule is encapsulated in its own class and can be combined using logical operators.

👍 Pros

• Highly reusable and testable

• Easy to compose complex rules

• Promotes separation of concerns

👎 Cons

• Can lead to many small classes

• Slightly more verbose than inline logic

---

🧾 2. Event Sourcing – Storing State as Events

✅ Intent

Store the state of a system as a sequence of events.

🎯 Use When

You want to track everything that happened, such as notifications sent, canceled, or retried.

🧩 Code

public abstract class NotificationEvent
{
    public DateTime Timestamp { get; } = DateTime.UtcNow;
}

public class NotificationSent : NotificationEvent
{
    public string Message { get; }

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

public class EventStore
{
    private readonly List<NotificationEvent> _events = new();

    public void Add(NotificationEvent e) => _events.Add(e);

    public IEnumerable<NotificationEvent> GetAll() => _events;
}

✅ Explanation

Events are stored instead of final state, allowing full reconstruction and auditability.

👍 Pros

• Full history of changes

• Great for auditing and debugging

• Enables time travel and replay

👎 Cons

• Requires more storage and management

• Complex to query current state

---

🚦 3. Throttling – Rate Limiting

✅ Intent

Limit the number of actions within a time window.

🎯 Use When

You want to prevent overload, such as limiting the number of notifications per minute.

🧩 Code

public class Throttler
{
    private readonly int _limit;
    private readonly TimeSpan _interval;
    private readonly Queue<DateTime> _timestamps = new();

    public Throttler(int limit, TimeSpan interval)
    {
        _limit = limit;
        _interval = interval;
    }

    public bool CanSend()
    {
        var now = DateTime.UtcNow;

        while (_timestamps.Count > 0 && now - _timestamps.Peek() > _interval)
            _timestamps.Dequeue();

        if (_timestamps.Count < _limit)
        {
            _timestamps.Enqueue(now);
            return true;
        }

        return false;
    }
}

✅ Explanation

Keeps track of timestamps and enforces a limit within a time window.

👍 Pros

• Prevents abuse or overload

• Easy to implement

• Useful for APIs and messaging systems

👎 Cons

• Requires time tracking logic

• May block legitimate requests

---

🔁 4. Retry – Fault-Tolerant Execution

✅ Intent

Retry a failed operation until it succeeds or reaches a limit.

🎯 Use When

You want to handle transient failures, such as network issues when sending notifications.

🧩 Code

public class RetryPolicy
{
    public static void Execute(Action action, int maxAttempts = 3)
    {
        int attempts = 0;
        while (attempts < maxAttempts)
        {
            try
            {
                action();
                return;
            }
            catch
            {
                attempts++;
                Thread.Sleep(500); // wait between attempts
            }
        }

        Console.WriteLine("Failed after multiple attempts.");
    }
}

✅ Explanation

Wraps an action in retry logic with a delay between attempts.

👍 Pros

• Improves resilience

• Handles temporary failures gracefully

• Simple to apply

👎 Cons

• Can mask deeper issues

• May cause delays or overload if abused

---

🧪 5. Pipeline – Step-by-Step Processing

✅ Intent

Chain multiple processing steps in sequence.

🎯 Use When

You want to process notifications through multiple filters or transformations.

🧩 Code

public interface IPipelineStep
{
    string Process(string message);
}

public class TrimStep : IPipelineStep
{
    public string Process(string message) => message.Trim();
}

public class UppercaseStep : IPipelineStep
{
    public string Process(string message) => message.ToUpper();
}

public class NotificationPipeline
{
    private readonly List<IPipelineStep> _steps = new();

    public void AddStep(IPipelineStep step) => _steps.Add(step);

    public string Execute(string message)
    {
        foreach (var step in _steps)
            message = step.Process(message);

        return message;
    }
}

✅ Explanation

Each step transforms the message, allowing modular and reusable processing.

👍 Pros

• Clean separation of concerns

• Easy to extend or reorder steps

• Great for validation, transformation, and enrichment

👎 Cons

• Can become hard to debug if steps fail silently

• Requires consistent step interfaces

---

🧾 Conclusion

These 5 patterns are especially useful in modern, distributed, or event-driven systems:

• Specification enables flexible rule composition

• Event Sourcing captures system history

• Throttling controls frequency

• Retry adds resilience

• Pipeline organizes processing flow

#CSharp #DesignPatterns #DotNet #SoftwareEngineering #CleanArchitecture #BackendDev #CodeQuality #ProgrammingTips #SpecificationPattern #EventSourcingPattern #ThrottlingPattern #RetryPattern #PipelinePattern