Zum Inhalt
wannacode

Template Method und Iterator

Kurz gesagt: Template Method hält das gemeinsame Gerüst eines Algorithmus in einer Basisklasse, während Unterklassen die Schritte ausfüllen; Iterator gibt Elemente eins nach dem anderen heraus, ohne zu zeigen, wie sie gespeichert sind.

Problem

Zwei Berichte mit demselben Gerüst

Die Buchhaltung will die Bestellungen als CSV, und die Website will dieselben als HTML-Tabelle. Stornierte Bestellungen kommen nicht in den Bericht. Jemand hat den CSV-Bericht geschrieben und dann die Methode für HTML kopiert:

static string ExportCsv(List<Order> orders)
{
    var lines = new List<string>();
    lines.Add("Bestellung,Summe");
    decimal sum = 0;
    foreach (var order in orders)
    {
        if (order.Cancelled)
        {
            continue;
        }
        lines.Add($"{order.Id},{order.Total:F2}");
        sum += order.Total;
    }
    lines.Add($"gesamt,{sum:F2}");
    return string.Join("\n", lines);
}


static string ExportHtml(List<Order> orders)
{
    var lines = new List<string>();
    lines.Add("<table>");
    lines.Add("<tr><th>Bestellung</th><th>Summe</th></tr>");
    decimal sum = 0;
    foreach (var order in orders)
    {
        lines.Add($"<tr><td>{order.Id}</td><td>{order.Total:F2}</td></tr>");
        sum += order.Total;
    }
    lines.Add($"<tr><td>Gesamt</td><td>{sum:F2}</td></tr>");
    lines.Add("</table>");
    return string.Join("\n", lines);
}
var orders = new List<Order>
{
    new Order(1001, 80.00m, false),
    new Order(1002, 25.50m, false),
    new Order(1003, 40.00m, true),
};
Console.WriteLine(ExportCsv(orders));
Console.WriteLine(ExportHtml(orders));
Ausgabe
Bestellung,Summe
1001,80.00
1002,25.50
gesamt,105.50
<table>
<tr><th>Bestellung</th><th>Summe</th></tr>
<tr><td>1001</td><td>80.00</td></tr>
<tr><td>1002</td><td>25.50</td></tr>
<tr><td>1003</td><td>40.00</td></tr>
<tr><td>Gesamt</td><td>145.50</td></tr>
</table>

Die beiden Berichte zeigen eine unterschiedliche Summe: CSV sagt 105.50 €, und HTML sagt 145.50 €. Die Regel „stornierte Bestellungen zählen nicht“ gibt es nur in der ersten Kopie. Beide Kopien tun dasselbe: Sie öffnen, schreiben eine Kopfzeile, laufen über die Bestellungen, schreiben die Summe und schließen. Nur die Zeilen, die sie schreiben, sind verschieden. Ein drittes Format wird eine dritte Kopie, und die Regel muss an noch einer Stelle im Kopf behalten werden.

Die Idee

Template Method: ein Gerüst, verschiedene Schritte

Was sich nicht ändert, ist die Reihenfolge der Schritte und die Regeln dazwischen: öffnen, Kopfzeile, eine Zeile für jede Bestellung außer den stornierten, Summe, schließen. Was sich ändert, ist, wie jeder Schritt aussieht.

Das Gerüst kommt in die Basisklasse Report, in die Methode Export. An jeder Stelle, an der sich die Formate unterscheiden, ruft sie einen Schritt auf: Header, Row, Footer. Die Unterklasse schreibt nur die Schritte. Ein Schritt, der optional ist (Open und Close, die CSV nicht nutzt), hat in der Basisklasse einen leeren Rumpf und heißt Hook.

Das ist das Muster Template Method. Es hat zwei Rollen:

  • die Basisklasse mit dem Gerüst: Sie bestimmt die Reihenfolge und ruft die Schritte auf;
  • die Unterklassen: CsvReport und HtmlReport schreiben die Schritte und rufen selbst nichts auf.

Sieh es dir an

Das Gerüst und die beiden Berichte

Export ist nicht virtual, deshalb kann eine Unterklasse es nicht ändern. Die Schritte sind protected und abstract, bis auf die beiden Hooks, die virtual sind und einen leeren Rumpf haben:
abstract class Report
{
    public string Export(List<Order> orders)
    {
        var lines = new List<string>();
        Open(lines);
        Header(lines);
        decimal sum = 0;
        foreach (var order in orders)
        {
            if (order.Cancelled)
            {
                continue;
            }
            Row(lines, order);
            sum += order.Total;
        }
        Footer(lines, sum);
        Close(lines);
        return string.Join("\n", lines);
    }


    protected virtual void Open(List<string> lines) { }
    protected abstract void Header(List<string> lines);
    protected abstract void Row(List<string> lines, Order order);
    protected abstract void Footer(List<string> lines, decimal sum);
    protected virtual void Close(List<string> lines) { }
}

Die beiden Berichte schreiben nur ihre Zeilen. CsvReport schreibt die Hooks nicht und nutzt deshalb die leeren aus der Basisklasse:

class CsvReport : Report
{
    protected override void Header(List<string> lines) => lines.Add("Bestellung,Summe");
    protected override void Row(List<string> lines, Order order) => lines.Add($"{order.Id},{order.Total:F2}");
    protected override void Footer(List<string> lines, decimal sum) => lines.Add($"gesamt,{sum:F2}");
}


class HtmlReport : Report
{
    protected override void Open(List<string> lines) => lines.Add("<table>");
    protected override void Header(List<string> lines) => lines.Add("<tr><th>Bestellung</th><th>Summe</th></tr>");
    protected override void Row(List<string> lines, Order order) => lines.Add($"<tr><td>{order.Id}</td><td>{order.Total:F2}</td></tr>");
    protected override void Footer(List<string> lines, decimal sum) => lines.Add($"<tr><td>Gesamt</td><td>{sum:F2}</td></tr>");
    protected override void Close(List<string> lines) => lines.Add("</table>");
}
var orders = new List<Order>
{
    new Order(1001, 80.00m, false),
    new Order(1002, 25.50m, false),
    new Order(1003, 40.00m, true),
};
Console.WriteLine(new CsvReport().Export(orders));
Console.WriteLine(new HtmlReport().Export(orders));
Ausgabe
Bestellung,Summe
1001,80.00
1002,25.50
gesamt,105.50
<table>
<tr><th>Bestellung</th><th>Summe</th></tr>
<tr><td>1001</td><td>80.00</td></tr>
<tr><td>1002</td><td>25.50</td></tr>
<tr><td>Gesamt</td><td>105.50</td></tr>
</table>

abstract class Report
{
    public string Export(List<Order> orders)
    {
        var lines = new List<string>();
        Open(lines);
        Header(lines);
        decimal sum = 0;
        foreach (var order in orders)
        {
            if (order.Cancelled)
            {
                continue;
            }
            Row(lines, order);
            sum += order.Total;
        }
        Footer(lines, sum);
        Close(lines);
        return string.Join("\n", lines);
    }


    protected virtual void Open(List<string> lines) { }
    protected abstract void Header(List<string> lines);
    protected abstract void Row(List<string> lines, Order order);
    protected abstract void Footer(List<string> lines, decimal sum);
    protected virtual void Close(List<string> lines) { }
}
Schritt für Schritt, in Worten
  1. new CsvReport().Export(orders): Das Gerüst steckt in Report. Es bestimmt die Reihenfolge der Schritte.
  2. Open: CsvReport schreibt diesen Schritt nicht, deshalb läuft der leere Rumpf aus Report. Es wird nichts hinzugefügt.
  3. Header: Das Gerüst ruft den Schritt auf, und CsvReport schreibt seine Zeile.
  4. Row für Bestellung 1001: Das Gerüst ruft den Schritt auf, und CsvReport schreibt seine Zeile.
  5. Row für Bestellung 1002: Das Gerüst ruft den Schritt auf, und CsvReport schreibt seine Zeile.
  6. Bestellung 1003 ist storniert: Das Gerüst selbst überspringt sie mit continue. Kein Bericht muss sich diese Regel merken.
  7. Footer: Das Gerüst ruft den Schritt auf, und CsvReport schreibt seine Zeile.
  8. Close: CsvReport schreibt diesen Schritt nicht, deshalb läuft der leere Rumpf aus Report. Es wird nichts hinzugefügt.
  9. Jetzt HtmlReport: dasselbe Gerüst, andere Schritte.
  10. Open: Das Gerüst ruft den Schritt auf, und HtmlReport schreibt seine Zeile.
  11. Header: Das Gerüst ruft den Schritt auf, und HtmlReport schreibt seine Zeile.
  12. Row für Bestellung 1001: Das Gerüst ruft den Schritt auf, und HtmlReport schreibt seine Zeile.
  13. Row für Bestellung 1002: Das Gerüst ruft den Schritt auf, und HtmlReport schreibt seine Zeile.
  14. Bestellung 1003 ist storniert: Das Gerüst selbst überspringt sie mit continue. Kein Bericht muss sich diese Regel merken.
  15. Footer: Das Gerüst ruft den Schritt auf, und HtmlReport schreibt seine Zeile.
  16. Close: Das Gerüst ruft den Schritt auf, und HtmlReport schreibt seine Zeile.
  17. Zwei Berichte, ein Gerüst. Beide Summen sind 105.50 €, weil die Regel zu stornierten Bestellungen an einer einzigen Stelle steht.

Die Summe ist in beiden Berichten 105.50 €: Die Regel zu stornierten Bestellungen steckt im Gerüst, an einer einzigen Stelle.

Sieh es dir an

Das Gerüst wird nicht angefasst

Eine Unterklasse, die versucht, ihr eigenes Export zu schreiben, lässt sich nicht kompilieren:

class QuickCsvReport : CsvReport
{
    public override string Export(List<Order> orders)
    {
        return "Bestellung,Summe";
    }
}
Fehler
error CS0506: 'QuickCsvReport.Export(List<Order>)': cannot override inherited member 'Report.Export(List<Order>)' because it is not marked virtual, abstract, or override
In C# werden Methoden nur überschrieben, wenn sie virtual sind, deshalb ist das Gerüst von selbst geschützt. Schreibt die Unterklasse Export ohne override, wird es eine neue Methode, die die alte verdeckt (Warnung CS0108), und Report r = new QuickCsvReport() ruft weiterhin das Gerüst auf.

Sieh es dir an

Ohne Vererbung: die Schritte als Funktionen

Die Schritte müssen keine Methoden einer Unterklasse sein. Das Gerüst kann sie als Parameter nehmen: Die Kopfzeile ist Text, und die Zeile und die Summe sind Funktionen.

static string Export(List<Order> orders, string header, Func<Order, string> row, Func<decimal, string> footer)
{
    var lines = new List<string> { header };
    decimal sum = 0;
    foreach (var order in orders)
    {
        if (order.Cancelled)
        {
            continue;
        }
        lines.Add(row(order));
        sum += order.Total;
    }
    lines.Add(footer(sum));
    return string.Join("\n", lines);
}
Console.WriteLine(Export(orders,
    "Bestellung,Summe",
    order => $"{order.Id},{order.Total:F2}",
    sum => $"gesamt,{sum:F2}"));
Console.WriteLine(Export(orders,
    "<table>\n<tr><th>Bestellung</th><th>Summe</th></tr>",
    order => $"<tr><td>{order.Id}</td><td>{order.Total:F2}</td></tr>",
    sum => $"<tr><td>Gesamt</td><td>{sum:F2}</td></tr>\n</table>"));
Ausgabe
Bestellung,Summe
1001,80.00
1002,25.50
gesamt,105.50
<table>
<tr><th>Bestellung</th><th>Summe</th></tr>
<tr><td>1001</td><td>80.00</td></tr>
<tr><td>1002</td><td>25.50</td></tr>
<tr><td>Gesamt</td><td>105.50</td></tr>
</table>

Das Gerüst steckt weiterhin an einer einzigen Stelle, und stornierte Bestellungen zählen weiterhin nicht.

Das ist Strategy für jeden Schritt: Func<Order, string> statt einer abstrakten Methode. Für zwei oder drei kurze Schritte genügt es. Eine Unterklasse lohnt sich, wenn es viele Schritte gibt, sie Felder teilen oder manche optional sind, wie die Hooks Open und Close.

Problem

Jeder, der die Bestellungen will, blättert die Seiten um

Die Bestellungen liegen in einem System, das sie seitenweise liefert: zwei pro Anfrage, weil eine Anfrage langsam ist. Hier ist die Quelle eine Liste im Speicher, und jedes Laden gibt eine Zeile aus, damit du siehst, wann es passiert:

class OrderSource
{
    private readonly List<Order> orders;


    public OrderSource(List<Order> orders)
    {
        this.orders = orders;
    }


    public List<Order> FetchPage(int number)
    {
        Console.WriteLine($"Seite wird geladen {number}");
        int from = Math.Min((number - 1) * 2, orders.Count);
        int count = Math.Min(2, orders.Count - from);
        return orders.GetRange(from, count);
    }
}

Der Bericht, die E-Mail an die Kunden und der Export wollen alle Bestellungen, und jeder blättert die Seiten selbst um:

int number = 1;
var page = source.FetchPage(number);
while (page.Count > 0)
{
    foreach (var order in page)
    {
        Console.WriteLine(order.Id);
    }
    number++;
    page = source.FetchPage(number);
}
Ausgabe
Seite wird geladen 1
1001
1002
Seite wird geladen 2
1003
1004
Seite wird geladen 3
1005
Seite wird geladen 4

Der Code, der nur „jede Bestellung der Reihe nach“ will, weiß, dass es Seiten gibt, wie sie gezählt werden und dass das Ende eine leere Seite ist. Dieselben Zeilen stehen in drei Dateien. Wenn das System von Seitenzahlen auf „einen Schlüssel für die nächste Seite“ umsteigt, änderst du alle drei.

Die Idee

Iterator: etwas hinter einem Cursor durchlaufen

Der Aufrufer will eines: die nächste Bestellung, solange es eine gibt. Wie man zu ihr kommt (eine Liste, Seiten, eine Datei, das Netzwerk), ist die Sache von jemand anderem.

Dieser jemand ist der Cursor: ein Objekt, das sich merkt, wie weit es gekommen ist, und die Frage „gibt es noch mehr?“ selbst beantwortet, wobei es eine neue Seite erst lädt, wenn die vorige zu Ende ist. Der Aufrufer schreibt ein gewöhnliches foreach und weiß nichts von den Seiten.

Das ist das Muster Iterator. Es hat zwei Rollen:

  • die Collection: das, was durchlaufen wird. Sie liefert einen Cursor;
  • der Cursor: merkt sich die Stelle und liefert das nächste Element.

Dieses Muster ist in jede der vier Sprachen eingebaut: foreach funktioniert mit jedem Objekt, das einen Cursor liefert. In C# ist die Collection ein IEnumerable<T>, und der Cursor ist ein IEnumerator<T> mit MoveNext() und Current. Den Cursor schreibst du nicht von Hand: yield return schreibt ihn für dich.

Sieh es dir an

Der Cursor, der die Seiten lädt

yield return gibt eine Bestellung heraus und hält die Funktion genau dort an, bis foreach nach der nächsten fragt. Deshalb wird die nächste Seite erst geladen, wenn die aktuelle zu Ende ist:
static IEnumerable<Order> AllOrders(OrderSource source)
{
    for (int number = 1; ; number++)
    {
        var page = source.FetchPage(number);
        if (page.Count == 0)
        {
            yield break;
        }
        foreach (var order in page)
        {
            yield return order;
        }
    }
}

Der Aufrufer weiß nichts von den Seiten:

foreach (var order in AllOrders(source))
{
    Console.WriteLine(order.Id);
}
Ausgabe
Seite wird geladen 1
1001
1002
Seite wird geladen 2
1003
1004
Seite wird geladen 3
1005
Seite wird geladen 4

static IEnumerable<Order> AllOrders(OrderSource source)
{
    for (int number = 1; ; number++)
    {
        var page = source.FetchPage(number);
        if (page.Count == 0)
        {
            yield break;
        }
        foreach (var order in page)
        {
            yield return order;
        }
    }
}


foreach (var order in AllOrders(source))
{
    Console.WriteLine(order.Id);
}
Schritt für Schritt, in Worten
  1. Die Schleife verlangt die erste Bestellung. Noch ist nichts geladen.
  2. AllOrders mit yield hat noch keine Seite, deshalb lädt er Seite 1.
  3. 1001: Die erste Bestellung der Seite geht an die Schleife, und die Schleife gibt sie aus.
  4. 1002: von derselben Seite. Es wird nichts geladen.
  5. Die Seite ist zu Ende. Erst jetzt lädt der Cursor Seite 2.
  6. 1003 und 1004 von Seite 2.
  7. Wieder die Grenze: Seite 3.
  8. 1005: Auf Seite 3 steht nur eine Bestellung.
  9. Seite 4 ist leer: Es gibt keine Bestellungen mehr.
  10. Der Cursor sagt „keine mehr“, und die Schleife endet. Die Schleife hat nie eine Seite gesehen.

Die Ausgabe ist dieselbe, und das Zählen der Seiten steckt an einer einzigen Stelle. Wenn das System die Art ändert, wie es Seiten liefert, änderst du die Funktion mit yield, und die drei Stellen, die die Bestellungen durchlaufen, bleiben unberührt.

Sieh es dir an

Was for-each innen macht

foreach ist eine Kurzschreibweise für diese Schleife mit dem Cursor:

using IEnumerator<Order> it = AllOrders(source).GetEnumerator();
while (it.MoveNext())
{
    Order order = it.Current;
    Console.WriteLine(order.Id);
}
Ausgabe
Seite wird geladen 1
1001
1002
Seite wird geladen 2
1003
1004
Seite wird geladen 3
1005
Seite wird geladen 4
foreach ruft einmal GetEnumerator() auf und dann bei jedem Schritt MoveNext() und Current. yield return hat den Compiler diese Cursor-Klasse für dich schreiben lassen.

Probier es aus

Sage die Ausgabe voraus

Die Schleife hört nach der dritten Bestellung auf. Was gibt das Programm aus?

int shown = 0;
foreach (var order in AllOrders(source))
{
    Console.WriteLine(order.Id);
    shown++;
    if (shown == 3)
    {
        break;
    }
}
Antwort

Probier es aus

Finde den Fehler

Die E-Mail an die Kunden sagt zuerst, wie viele Bestellungen es sind, und listet sie dann auf:

var orders = AllOrders(new OrderSource(all));
int count = 0;
foreach (var order in orders)
{
    count++;
}
Console.WriteLine($"Bestellungen: {count}");
foreach (var order in orders)
{
    Console.WriteLine(order.Id);
}
Ausgabe
Seite wird geladen 1
Seite wird geladen 2
Seite wird geladen 3
Seite wird geladen 4
Bestellungen: 5
Seite wird geladen 1
1001
1002
Seite wird geladen 2
1003
1004
Seite wird geladen 3
1005
Seite wird geladen 4
Die Nummern kommen heraus, aber jede Seite wird zweimal geladen, und die Quelle ist langsam. Welche Zeile musst du ändern?

Wähle die Zeile mit dem Fehler.

Die Idee

Wann du sie nicht brauchst

Template Method hat einen Preis: eine Basisklasse und Vererbung, und Vererbung ist eine Bindung, die sich schwer lösen lässt. Es lohnt sich nicht, wenn:

  • es ein einziges Format gibt. Eine einzige Methode ohne Schritte ist klarer;
  • es ein oder zwei Schritte gibt. Reiche sie als Lambdas weiter, wie in der Karte „Ohne Vererbung“;
  • die Unterklassen auch die Reihenfolge der Schritte ändern wollen. Dann ist das Gerüst nicht gemeinsam, und wenn du es erzwingst, bekommst du Schritte mit einem if darin.

Einen eigenen Iterator brauchst du nicht, wenn die Daten schon in einer Liste liegen: Sie lässt sich schon durchlaufen. Du schreibst einen eigenen, wenn dahinter etwas steckt, das keine Collection im Speicher ist: Seiten, eine zeilenweise gelesene Datei, ein Baum oder eine endlose Folge (Rechnungsnummern).

Übung

Ein Bericht in Markdown

Löse die Aufgabe in deinem Editor.

Markdown. Die Dokumentationsseite will den Bericht als Markdown-Tabelle. Schreibe MarkdownReport, der nur die Schritte schreibt. Die Kopfzeile besteht aus zwei Zeilen. Report und die anderen Berichte werden nicht angefasst. Mit den Bestellungen aus der Lektion:

Ausgabe
| Bestellung | Summe |
|---|---|
| 1001 | 80.00 |
| 1002 | 25.50 |
| **Gesamt** | 105.50 |

Weitere Aufgaben

  • Zeilennummern. Der HTML-Bericht nummeriert seine Zeilen (<td>1</td>, <td>2</td>), und stornierte Bestellungen zählen nicht. Wo hältst du den Zähler: im Gerüst oder in HtmlReport?
  • Die ersten N. Schreibe eine Methode mit yield, der nur die ersten N Bestellungen aus einem anderen Cursor liefert. Wie viele Seiten werden für die ersten drei geladen?
  • Nur die großen. Laufe über die Bestellungen der Quelle und liefere nur die über 30 €, wieder ohne dass der Aufrufer etwas von den Seiten weiß.

Test

Teste dich

1. Der Shop will den Bericht auch als JSON. Was schreibst du mit Template Method?
2. Warum hat der Schritt open in der Basisklasse einen leeren Rumpf, während header abstrakt ist?
3. Eine Schleife läuft über die Bestellungen der langsamen Quelle und hört bei der zweiten mit break auf. Wie viele Seiten werden geladen?
4. Was ruft for-each auf, um etwas zu durchlaufen?

Erstellt von Ivo Gergov im Rahmen der Kampagne von Evo Tech für zugängliche Programmierausbildung ·