Design Patterns in Modern C#

Behavioral Patterns#

Behavioral patterns govern how responsibility is distributed and how objects communicate once they are built and composed.

Strategy#

Strategy selects one of several interchangeable algorithms at runtime. Keyed dependency injection, available since .NET 8, resolves a named strategy directly from the container instead of hand-writing a switch statement over an enum:

builder.Services.AddKeyedSingleton<IDiscountStrategy, VipDiscountStrategy>("vip");
builder.Services.AddKeyedSingleton<IDiscountStrategy, StandardDiscountStrategy>("standard");

public sealed class PricingService(IServiceProvider services)
{
    public decimal ApplyDiscount(Order order, string customerTier) =>
        services.GetRequiredKeyedService<IDiscountStrategy>(customerTier).Apply(order);
}

Observer#

Observer lets one or more subscribers react to something happening in another object without that object knowing who, or how many, are listening. C#'s event keyword and multicast delegates are the language's built-in implementation, and IObservable<T>/IObserver<T> (and the Rx.NET library built on them) extend the same idea to asynchronous streams of values. Reach for a plain event for simple, synchronous, in-process notifications, and for the in-process integration events pattern when several independent modules need to react to the same fact.

Command#

Command turns a request into a standalone object, carrying everything needed to execute it later, queue it, log it, or undo it. System.Windows.Input.ICommand is the built-in example behind every bound button in WPF and MAUI, and at the application layer, libraries such as MediatR, the MIT-licensed Mediator source generator, or Wolverine implement the same pattern for commands and queries flowing through a pipeline of cross-cutting behaviors. Use it when you need to decouple a caller from a handler, queue work, or wrap every request in the same logging, validation and transaction behavior; skip it for a simple method call that has, and will likely always have, exactly one caller and one implementation.

Chain of Responsibility#

Chain of Responsibility passes a request along a sequence of handlers, each of which can act on it, pass it on, or short-circuit the chain. ASP.NET Core's middleware pipeline is this pattern at the framework level, and writing your own middleware follows the same shape:

public sealed class CorrelationIdMiddleware(RequestDelegate next)
{
    public async Task InvokeAsync(HttpContext context)
    {
        context.Items["CorrelationId"] = context.Request.Headers["X-Correlation-Id"].FirstOrDefault()
            ?? Guid.NewGuid().ToString("n");
        await next(context); // pass control to the next link in the chain
    }
}

Template Method#

Template Method fixes the skeleton of an algorithm in a base class while letting subclasses override individual steps. It is the least fashionable pattern in modern C#, since composition and delegates usually age better than inheritance, but it still fits a small, closed set of variants that share a strict sequence:

public abstract class ReportGenerator
{
    public async Task<byte[]> GenerateAsync(CancellationToken ct)
    {
        var data = await FetchDataAsync(ct);
        var formatted = Format(data);
        return await RenderAsync(formatted, ct); // the fixed skeleton
    }

    protected abstract Task<IReadOnlyList<OrderRecord>> FetchDataAsync(CancellationToken ct);
    protected abstract string Format(IReadOnlyList<OrderRecord> data);
    protected virtual Task<byte[]> RenderAsync(string formatted, CancellationToken ct) =>
        Task.FromResult(Encoding.UTF8.GetBytes(formatted));
}

State#

State lets an object change its behavior as its internal state changes, without a wall of if statements checking a status field everywhere the object is used. Modern C# often expresses this more concisely with a closed set of records and a switch expression than with a class per state:

public abstract record OrderState;
public sealed record Placed : OrderState;
public sealed record Shipped(string TrackingNumber) : OrderState;
public sealed record Delivered(DateOnly Date) : OrderState;

public static string Describe(OrderState state) => state switch
{
    Placed => "Waiting to ship",
    Shipped s => $"In transit, tracking {s.TrackingNumber}",
    Delivered d => $"Delivered on {d.Date}",
    _ => throw new ArgumentOutOfRangeException(nameof(state))
};

A traditional class-per-state implementation, where each state type also decides which state comes next, is still worth it when the transitions themselves carry real behavior, not just data.