In der Praxis: Auswahl, DI und die leichte Variante

Eine Frage ist offen geblieben: Die Kasse entscheidet nicht mehr — aber irgendwer muss entscheiden, welche Strategie es sein soll. Das Pattern schafft die Verzweigung nicht ab, es verschiebt sie an den Rand.

Im .NET-Alltag gibt es dafür drei gängige Antworten.

1. Alle registrieren, per Schlüssel auswählen

Jede Strategie sagt selbst, wofür sie zuständig ist. Ein kleiner Auswähler sammelt sie ein.

public interface IVersandkosten
{
    string Art { get; }
    decimal Berechne(Bestellung bestellung);
}

public sealed class VersandAuswahl
{
    private readonly Dictionary<string, IVersandkosten> _nachArt;

    public VersandAuswahl(IEnumerable<IVersandkosten> strategien) =>
        _nachArt = strategien.ToDictionary(s => s.Art, StringComparer.OrdinalIgnoreCase);

    public IVersandkosten Fuer(string art) =>
        _nachArt.TryGetValue(art, out var s)
            ? s
            : throw new ArgumentException($"Unbekannte Versandart: {art}");
}

builder.Services.AddSingleton<IVersandkosten, StandardVersand>();
builder.Services.AddSingleton<IVersandkosten, ExpressVersand>();
builder.Services.AddSingleton<IVersandkosten, Abholung>();
builder.Services.AddSingleton<VersandAuswahl>();

2. Keyed Services

Seit .NET 8 kann der Container den Schlüssel selbst verwalten, und der eigene Auswähler entfällt:

builder.Services.AddKeyedSingleton<IVersandkosten, StandardVersand>("standard");
builder.Services.AddKeyedSingleton<IVersandkosten, ExpressVersand>("express");

// Im Konstruktor:
public Kasse([FromKeyedServices("express")] IVersandkosten versand) => ...

// Oder zur Laufzeit, wenn die Art erst dann bekannt ist:
var strategie = serviceProvider.GetRequiredKeyedService<IVersandkosten>(art);

3. Die leichte Variante: ein Delegate

Nicht jede Strategie braucht eine Schnittstelle und eine Klasse. Wenn das Verfahren eine Methode ist und keinen eigenen Zustand hat, ist ein Func<> dieselbe Idee in einer Zeile:

public interface ISortierung
{
    IEnumerable<Artikel> Sortiere(
        IEnumerable<Artikel> artikel);
}

public sealed class NachPreis : ISortierung
{
    public IEnumerable<Artikel> Sortiere(
        IEnumerable<Artikel> a) =>
            a.OrderBy(x => x.Preis);
}

Func<IEnumerable<Artikel>,
     IEnumerable<Artikel>> nachPreis =
        a => a.OrderBy(x => x.Preis);

// Übergeben wie jede andere Strategie:
var liste = Anzeigen(artikel, nachPreis);

Nimm das Interface, wenn die Strategie einen Namen verdient, mehrere Methoden hat, eigene Abhängigkeiten braucht oder aus dem DI-Container kommen soll. Nimm das Delegate für alles andere.

Woran du merkst, dass es zu weit ging

• Es gibt genau eine Implementierung, und seit zwei Jahren kam keine dazu.
• Die Schnittstelle hat einen Parameter, den nur eine einzige Implementierung benutzt — dann sind die Strategien nicht wirklich austauschbar.
• Um eine Verzweigung zu verstehen, musst du vier Dateien öffnen, obwohl die Fälle sich nie ändern.

Strategy zahlt sich dort aus, wo Fälle kommen und gehen. Wo sie stehen, ist ein switch ehrlicher.