Template Method и Iterator

Код на:JavaC#PythonJavaScript

Накратко: Template Method пази общия скелет на алгоритъм в базов клас, а подкласовете попълват стъпките; Iterator дава елементите един по един, без да показва как се пазят.

Проблем

Два отчета с един и същ скелет

Счетоводството иска поръчките в CSV, а сайтът иска същите в HTML таблица. Отказаните поръчки не влизат в отчета. Някой написа CSV, а после копира метода за HTML:

static string ExportCsv(List<Order> orders)
{
    var lines = new List<string>();
    lines.Add("поръчка,сума");
    decimal sum = 0;
    foreach (var order in orders)
    {
        if (order.Cancelled)
        {
            continue;
        }
        lines.Add($"{order.Id},{order.Total:F2}");
        sum += order.Total;
    }
    lines.Add($"общо,{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>Поръчка</th><th>Сума</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>Общо</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));

Изход

поръчка,сума
1001,80.00
1002,25.50
общо,105.50
<table>
<tr><th>Поръчка</th><th>Сума</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>Общо</td><td>145.50</td></tr>
</table>

Двата отчета показват различна сума: CSV е 105.50 €, а HTML е 145.50 €. Правилото „отказаните не влизат“ го има само в първото копие. Двете копия правят едно и също: отварят, пишат заглавие, обхождат поръчките, пишат сбора и затварят. Различни са само редовете, които пишат. Третият формат ще е трето копие, и правилото пак трябва да се помни на още едно място.

Идеята

Template Method: скелетът е един, стъпките са различни

Каквото не се сменя, е редът на стъпките и правилата между тях: отваряне, заглавие, по ред за всяка поръчка без отказаните, сбор, затваряне. Каквото се сменя, е как изглежда всяка стъпка.

Скелетът отива в базовия клас Report, в метода Export. На всяко място, където форматите се различават, той вика стъпка: Header, Row, Footer. Подкласът пише само стъпките. Стъпка, която не е задължителна (Open и Close, които CSV не ползва), има празно тяло в базовия клас и се казва кука (hook).

Това е шаблонът Template Method (шаблонен метод). Ролите са две:

• базовият клас със скелета: той решава реда и вика стъпките;
• подкласовете: CsvReport и HtmlReport пишат стъпките и не викат нищо сами.

Виж го

Скелетът и двата отчета

Export не е virtual, затова подкласът не може да го смени. Стъпките са protected и abstract, освен двете куки, които са virtual с празно тяло:

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) { }
}

Двата отчета пишат само редовете си. CsvReport не пише куките, затова ползва празните от базовия клас:

class CsvReport : Report
{
    protected override void Header(List<string> lines) => lines.Add("поръчка,сума");
    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($"общо,{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>Поръчка</th><th>Сума</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>Общо</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));

Изход

поръчка,сума
1001,80.00
1002,25.50
общо,105.50
<table>
<tr><th>Поръчка</th><th>Сума</th></tr>
<tr><td>1001</td><td>80.00</td></tr>
<tr><td>1002</td><td>25.50</td></tr>
<tr><td>Общо</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) { }
}

Стъпка по стъпка, с думи

1. new CsvReport().Export(orders): скелетът е в Report. Той решава реда на стъпките.
2. Open: CsvReport не пише тази стъпка, затова върви празното тяло от Report. Не се добавя нищо.
3. Header: скелетът вика стъпката, а CsvReport пише своя ред.
4. Row за поръчка 1001: скелетът вика стъпката, а CsvReport пише своя ред.
5. Row за поръчка 1002: скелетът вика стъпката, а CsvReport пише своя ред.
6. Поръчка 1003 е отказана: самият скелет я прескача с continue. Нито един отчет не трябва да помни това правило.
7. Footer: скелетът вика стъпката, а CsvReport пише своя ред.
8. Close: CsvReport не пише тази стъпка, затова върви празното тяло от Report. Не се добавя нищо.
9. Сега HtmlReport: същият скелет, други стъпки.
10. Open: скелетът вика стъпката, а HtmlReport пише своя ред.
11. Header: скелетът вика стъпката, а HtmlReport пише своя ред.
12. Row за поръчка 1001: скелетът вика стъпката, а HtmlReport пише своя ред.
13. Row за поръчка 1002: скелетът вика стъпката, а HtmlReport пише своя ред.
14. Поръчка 1003 е отказана: самият скелет я прескача с continue. Нито един отчет не трябва да помни това правило.
15. Footer: скелетът вика стъпката, а HtmlReport пише своя ред.
16. Close: скелетът вика стъпката, а HtmlReport пише своя ред.
17. Два отчета, един скелет. И двата сбора са 105.50 €, защото правилото за отказаните е на едно място.

Сборът е 105.50 € и в двата отчета: правилото за отказаните е в скелета, на едно място.

Виж го

Скелетът не се пипа

Подклас, който се опита да напише свой Export, не се компилира:

class QuickCsvReport : CsvReport
{
    public override string Export(List<Order> orders)
    {
        return "поръчка,сума";
    }
}

Грешка

error CS0506: 'QuickCsvReport.Export(List<Order>)': cannot override inherited member 'Report.Export(List<Order>)' because it is not marked virtual, abstract, or override

В C# методите не се презаписват, освен ако не са virtual, затова скелетът е защитен от само себе си. Ако подкласът напише Export без override, става нов метод, който скрива стария (предупреждение CS0108), и Report r = new QuickCsvReport() пак вика скелета.

Виж го

Без наследяване: стъпките като функции

Стъпките не е задължително да са методи на подклас. Скелетът може да ги приеме като параметри: заглавието е текст, а редът и сборът са функции.

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,
    "поръчка,сума",
    order => $"{order.Id},{order.Total:F2}",
    sum => $"общо,{sum:F2}"));
Console.WriteLine(Export(orders,
    "<table>\n<tr><th>Поръчка</th><th>Сума</th></tr>",
    order => $"<tr><td>{order.Id}</td><td>{order.Total:F2}</td></tr>",
    sum => $"<tr><td>Общо</td><td>{sum:F2}</td></tr>\n</table>"));

Изход

поръчка,сума
1001,80.00
1002,25.50
общо,105.50
<table>
<tr><th>Поръчка</th><th>Сума</th></tr>
<tr><td>1001</td><td>80.00</td></tr>
<tr><td>1002</td><td>25.50</td></tr>
<tr><td>Общо</td><td>105.50</td></tr>
</table>

Скелетът пак е на едно място, а отказаните пак не влизат.

Това е Strategy за всяка стъпка: Func<Order, string> вместо абстрактен метод. Стига за две-три кратки стъпки. Подкласът си заслужава, когато стъпките са много, имат общи полета или някои са по желание, както куките Open и Close.

Проблем

Всеки, който иска поръчките, върти страниците

Поръчките са в система, която ги дава на страници: по две на заявка, защото заявката е бавна. Тук източникът е списък в паметта, а всяко зареждане печата ред, за да виждаш кога става:

class OrderSource
{
    private readonly List<Order> orders;

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

    public List<Order> FetchPage(int number)
    {
        Console.WriteLine($"зареждам страница {number}");
        int from = Math.Min((number - 1) * 2, orders.Count);
        int count = Math.Min(2, orders.Count - from);
        return orders.GetRange(from, count);
    }
}

Отчетът, имейлът за клиентите и експортът искат всичките поръчки, и всеки върти страниците сам:

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);
}

Изход

зареждам страница 1
1001
1002
зареждам страница 2
1003
1004
зареждам страница 3
1005
зареждам страница 4

Кодът, който иска само „всяка поръчка поред“, знае, че има страници, как се броят и че краят е празна страница. Същите редове са в три файла. Когато системата мине от номер на страница към „ключ за следващата страница“, сменяш и трите.

Идеята

Iterator: обхождането зад курсор

Извикващият иска едно: следващата поръчка, докато има. Как се стига до нея (списък, страници, файл, мрежа) е работа на някой друг.

Този друг е курсорът: обект, който помни докъде е стигнал и на въпроса „има ли още?“ отговаря сам, като зарежда следваща страница, само когато предишната свърши. Извикващият пише обикновен foreach и не знае за страниците.

Това е шаблонът Iterator (итератор). Ролите са две:

• колекцията: това, което се обхожда. Тя дава курсор;
• курсорът: помни мястото и дава следващия елемент.

Този шаблон е вграден във всеки от четирите езика: foreach работи с всеки обект, който дава курсор. В C# колекцията е IEnumerable<T>, а курсорът IEnumerator<T> с MoveNext() и Current. Курсора не го пишеш на ръка: yield return го пише вместо теб.

Виж го

Курсорът, който зарежда страниците

yield return дава по една поръчка и спира функцията точно там, докато foreach не поиска следващата. Затова следващата страница се зарежда, едва когато текущата свърши:

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);
}

Изход

зареждам страница 1
1001
1002
зареждам страница 2
1003
1004
зареждам страница 3
1005
зареждам страница 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);
}

Стъпка по стъпка, с думи

1. Цикълът иска първата поръчка. Още нищо не е заредено.
2. AllOrders с yield още няма страница, затова зарежда страница 1.
3. 1001: първата поръчка от страницата отива в цикъла, а той я печата.
4. 1002: от същата страница. Нищо не се зарежда.
5. Страницата свърши. Едва сега курсорът зарежда страница 2.
6. 1003 и 1004 от страница 2.
7. Пак границата: страница 3.
8. 1005: на страница 3 има само една поръчка.
9. Страница 4 е празна: поръчки няма повече.
10. Курсорът казва „няма повече“, и цикълът свършва. Цикълът така и не видя страница.

Изходът е същият, а броенето на страници е на едно място. Когато системата смени начина, по който дава страниците, сменяш функцията с yield, а трите места, които обхождат, не се пипат.

Виж го

Какво прави for-each отвътре

foreach е кратък запис на този цикъл с курсора:

using IEnumerator<Order> it = AllOrders(source).GetEnumerator();
while (it.MoveNext())
{
    Order order = it.Current;
    Console.WriteLine(order.Id);
}

Изход

зареждам страница 1
1001
1002
зареждам страница 2
1003
1004
зареждам страница 3
1005
зареждам страница 4

foreach вика GetEnumerator() веднъж, а после MoveNext() и Current на всяка стъпка. yield return е накарал компилатора да напише този клас курсор вместо теб.

Пробвай

Предвиди изхода

Цикълът спира след третата поръчка. Какво печата програмата?

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

Отговор

зареждам страница 1 / 1001 / 1002 / зареждам страница 2 / 1003 / 1004

зареждам страница 1 / зареждам страница 2 / зареждам страница 3 / зареждам страница 4 / 1001 / 1002 / 1003

зареждам страница 1 / 1001 / 1002 / зареждам страница 2 / 1003

Провери

Пробвай

Намери грешката

Имейлът до клиентите първо казва колко са поръчките, а после ги изрежда:

var orders = AllOrders(new OrderSource(all));
int count = 0;
foreach (var order in orders)
{
    count++;
}
Console.WriteLine($"Поръчки: {count}");
foreach (var order in orders)
{
    Console.WriteLine(order.Id);
}

Изход

зареждам страница 1
зареждам страница 2
зареждам страница 3
зареждам страница 4
Поръчки: 5
зареждам страница 1
1001
1002
зареждам страница 2
1003
1004
зареждам страница 3
1005
зареждам страница 4

Номерата излизат, но всяка страница е заредена два пъти, а източникът е бавен. Кой ред трябва да смениш?

Избери реда с грешката.

1var orders = AllOrders(new OrderSource(all));2int count = 0;3foreach (var order in orders)4{5 count++;6}7Console.WriteLine($"Поръчки: {count}");8foreach (var order in orders)9{10 Console.WriteLine(order.Id);11}

Провери

Идеята

Кога не ти трябват

Template Method има цена: базов клас и наследяване, а наследяването е връзка, която трудно се развързва. Не си струва, когато:

• форматът е един. Един метод без стъпки е по-ясен;
• стъпките са една-две. Подай ги като ламбди, както в картата „Без наследяване“;
• подкласовете искат да сменят и реда на стъпките. Тогава скелетът не е общ, и насилването му ражда стъпки с if вътре.

Свой Iterator не ти трябва, когато данните вече са в списък: той вече се обхожда. Пишеш свой, когато отзад има нещо, което не е колекция в паметта: страници, файл, който се чете ред по ред, дърво, или безкрайна поредица (номерата на фактурите).

Упражнение

Отчет в Markdown

Реши задачата в редактора си.

Markdown. Сайтът с документацията иска отчета като Markdown таблица. Напиши MarkdownReport, който пише само стъпките. Заглавието е два реда. Report и другите отчети не се пипат. С поръчките от урока:

Изход

| Поръчка | Сума |
|---|---|
| 1001 | 80.00 |
| 1002 | 25.50 |
| **Общо** | 105.50 |

Още задачи

• Номер на реда. HTML отчетът номерира редовете (<td>1</td>, <td>2</td>), а отказаните не броят. Къде пазиш брояча: в скелета или в HtmlReport?
• Първите N. Напиши метод с yield, който дава само първите N поръчки от друг курсор. Колко страници се зареждат за първите три?
• Само големите. Обходи поръчките от източника и дай само тези над 30 €, пак без извикващият да знае за страниците.

Тест

Провери се

1. Магазинът иска отчет и в JSON. Какво пишеш при Template Method?

Нов if в export за всеки форматКопие на метода за CSV и го сменяшНов подклас на Report, който пише стъпките; скелетът не се пипа

2. Защо стъпката open има празно тяло в базовия клас, а header е абстрактна?

Абстрактните стъпки са по-бързиopen е по желание (CSV не я ползва), а без header отчетът няма смисълБез причина, може и двете да са абстрактни

3. Цикъл обхожда поръчките от бавния източник и спира с break на втората. Колко страници са заредени?

ЕднаВсичкитеДве

4. Какво вика for-each, за да обходи нещо?

Курсора на обекта: пита дали има следващ и го взимаМетод, който връща целия списък наведнъжИндексите от 0 до size()

Провери

Започни урока отначало

Свързани уроци

• Нужно отпреди: Ламбди и делегати · record, switch и шаблони · Шаблони за дизайн · Strategy
• Задачи по темата: Шаблони за дизайн