What is the Open/Closed Principle, and how do you apply it in C# without building speculative plug-in frameworks?

1. Origins

2. "Closed against what?"

No design is closed against every change. Choose the axis you observe:

Axis of change seen in history          Closure mechanism
new payment providers                   IPaymentProvider strategies
new export formats                      IExporter keyed by format
new discount types                      IEnumerable<IDiscountRule>
new cross-cutting behaviour             decorators / middleware

If the business instead starts changing how every provider is called (new step for all), your strategy interface itself changes; that's normal. Re-evaluate the axis.

3. Keyed services (.NET 8+)

builder.Services.AddKeyedScoped<IPaymentProvider, StripeProvider>("stripe");
builder.Services.AddKeyedScoped<IPaymentProvider, PayPalProvider>("paypal");

// Inject a specific one
public sealed class RefundService([FromKeyedServices("stripe")] IPaymentProvider stripe) { }

// Or resolve by runtime key
var provider = sp.GetRequiredKeyedService<IPaymentProvider>(method);

Before .NET 8, the usual pattern was IEnumerable<IPaymentProvider> with a Name property turned into a dictionary, or a factory.

4. The expression problem

That's why both styles are legitimate in C#. Discriminated-union-style records plus switch expressions suit closed hierarchies; interfaces suit open ones.

5. OCP and testing

• Contract tests: one shared test suite that every implementation must pass (also enforces Liskov).
• New variants are tested alone; existing tests remain green without modification.
• Architecture tests (e.g. NetArchTest) can enforce that Checkout doesn't reference concrete providers.

6. Smells pointing to a missing extension point

7. Try it yourself

1. Write a switch computing shipping cost for three carriers; add a fourth and list files and tests touched.
2. Refactor to IShippingCalculator keyed services; add a fifth and compare.
3. Write a contract test base class and run it against every carrier.
4. Model a closed set (GST categories) with a switch expression and enable warnings for unhandled enum values.
5. Find an interface in your codebase with one implementation; decide whether it earns its keep.

using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();
services.AddKeyedSingleton<IPaymentProvider, CardProvider>("card");
services.AddKeyedSingleton<IPaymentProvider, PayIdProvider>("payid"); // new provider: new class + one line
services.AddSingleton<Checkout>();
using var sp = services.BuildServiceProvider();

var checkout = sp.GetRequiredService<Checkout>();
Console.WriteLine(await checkout.PayAsync("payid", 49.95m));
Console.WriteLine(GstRates.Rate(Gst.Standard));

public interface IPaymentProvider
{
    Task<string> ChargeAsync(decimal amount, CancellationToken ct = default);
}

public sealed class CardProvider : IPaymentProvider
{
    public Task<string> ChargeAsync(decimal amount, CancellationToken ct = default) =>
        Task.FromResult($"Card charged {amount:C}");
}

public sealed class PayIdProvider : IPaymentProvider
{
    public Task<string> ChargeAsync(decimal amount, CancellationToken ct = default) =>
        Task.FromResult($"PayID request sent for {amount:C}");
}

// Closed for modification: adding a provider does not change this class.
public sealed class Checkout(IServiceProvider services)
{
    public Task<string> PayAsync(string method, decimal amount, CancellationToken ct = default) =>
        services.GetRequiredKeyedService<IPaymentProvider>(method).ChargeAsync(amount, ct);
}

// A closed set where a switch expression is clearer than a strategy per case.
public enum Gst { Standard, Free, InputTaxed }

public static class GstRates
{
    public static decimal Rate(Gst g) => g switch
    {
        Gst.Standard => 0.10m,
        Gst.Free or Gst.InputTaxed => 0m,
        _ => throw new ArgumentOutOfRangeException(nameof(g))
    };
}

Needs the Microsoft.Extensions.DependencyInjection package (8.0 or later for keyed services). Top-level await makes the entry point async, so PayAsync is awaited correctly.