Template Method e Iterator

Código en:JavaC#PythonJavaScript

En resumen: Template Method guarda el esqueleto común de un algoritmo en una clase base mientras las subclases rellenan los pasos; Iterator entrega los elementos uno por uno sin mostrar cómo están guardados.

Problema

Dos informes con el mismo esqueleto

Contabilidad quiere los pedidos en CSV, y el sitio web quiere los mismos en una tabla HTML. Los pedidos cancelados no entran en el informe. Alguien escribió el de CSV y luego copió la método para HTML:

static string ExportCsv(List<Order> orders)
{
    var lines = new List<string>();
    lines.Add("pedido,suma");
    decimal sum = 0;
    foreach (var order in orders)
    {
        if (order.Cancelled)
        {
            continue;
        }
        lines.Add($"{order.Id},{order.Total:F2}");
        sum += order.Total;
    }
    lines.Add($"total,{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>Pedido</th><th>Suma</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>Total</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));

Salida

pedido,suma
1001,80.00
1002,25.50
total,105.50
<table>
<tr><th>Pedido</th><th>Suma</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>Total</td><td>145.50</td></tr>
</table>

Los dos informes muestran una suma distinta: el CSV dice 105.50 €, y el HTML dice 145.50 €. La regla «los cancelados no cuentan» existe solo en la primera copia. Las dos copias hacen lo mismo: abren, escriben un encabezado, recorren los pedidos, escriben el total y cierran. Solo cambian las líneas que escriben. Un tercer formato será una tercera copia, y habrá que recordar la regla en un lugar más.

La idea

Template Method: un esqueleto, pasos distintos

Lo que no cambia es el orden de los pasos y las reglas entre ellos: abrir, encabezado, una fila por cada pedido salvo los cancelados, total, cerrar. Lo que cambia es cómo se ve cada paso.

El esqueleto va en la clase base Report, en el método Export. En cada lugar donde los formatos se diferencian, llama a un paso: Header, Row, Footer. La subclase escribe solo los pasos. Un paso que es opcional (Open y Close, que CSV no usa) tiene un cuerpo vacío en la clase base y se llama gancho (hook).

Este es el patrón Template Method. Tiene dos roles:

• la clase base con el esqueleto: decide el orden y llama a los pasos;
• las subclases: CsvReport y HtmlReport escriben los pasos y no llaman a nada por sí mismas.

Míralo

El esqueleto y los dos informes

Export no es virtual, así que una subclase no puede cambiarlo. Los pasos son protected y abstract, salvo los dos ganchos, que son virtual con cuerpo vacío:

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

Los dos informes escriben solo sus líneas. CsvReport no escribe los ganchos, así que usa los vacíos de la clase base:

class CsvReport : Report
{
    protected override void Header(List<string> lines) => lines.Add("pedido,suma");
    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($"total,{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>Pedido</th><th>Suma</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>Total</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));

Salida

pedido,suma
1001,80.00
1002,25.50
total,105.50
<table>
<tr><th>Pedido</th><th>Suma</th></tr>
<tr><td>1001</td><td>80.00</td></tr>
<tr><td>1002</td><td>25.50</td></tr>
<tr><td>Total</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) { }
}

Paso a paso, en palabras

1. new CsvReport().Export(orders): el esqueleto está en Report. Él decide el orden de los pasos.
2. Open: CsvReport no escribe este paso, así que se ejecuta el cuerpo vacío de Report. No se añade nada.
3. Header: el esqueleto llama al paso, y CsvReport escribe su línea.
4. Row para el pedido 1001: el esqueleto llama al paso, y CsvReport escribe su línea.
5. Row para el pedido 1002: el esqueleto llama al paso, y CsvReport escribe su línea.
6. El pedido 1003 está cancelado: el propio esqueleto lo salta con continue. Ningún informe tiene que recordar esta regla.
7. Footer: el esqueleto llama al paso, y CsvReport escribe su línea.
8. Close: CsvReport no escribe este paso, así que se ejecuta el cuerpo vacío de Report. No se añade nada.
9. Ahora HtmlReport: el mismo esqueleto, otros pasos.
10. Open: el esqueleto llama al paso, y HtmlReport escribe su línea.
11. Header: el esqueleto llama al paso, y HtmlReport escribe su línea.
12. Row para el pedido 1001: el esqueleto llama al paso, y HtmlReport escribe su línea.
13. Row para el pedido 1002: el esqueleto llama al paso, y HtmlReport escribe su línea.
14. El pedido 1003 está cancelado: el propio esqueleto lo salta con continue. Ningún informe tiene que recordar esta regla.
15. Footer: el esqueleto llama al paso, y HtmlReport escribe su línea.
16. Close: el esqueleto llama al paso, y HtmlReport escribe su línea.
17. Dos informes, un esqueleto. Las dos sumas son 105.50 €, porque la regla de los cancelados está en un solo lugar.

El total es 105.50 € en los dos informes: la regla de los cancelados está en el esqueleto, en un solo lugar.

Míralo

El esqueleto no se toca

Una subclase que intenta escribir su propio Export no compila:

class QuickCsvReport : CsvReport
{
    public override string Export(List<Order> orders)
    {
        return "pedido,suma";
    }
}

Error

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

En C#, los métodos no se sobrescriben a menos que sean virtual, así que el esqueleto está protegido por sí mismo. Si la subclase escribe Export sin override, se convierte en un método nuevo que oculta al viejo (advertencia CS0108), y Report r = new QuickCsvReport() sigue llamando al esqueleto.

Míralo

Sin herencia: los pasos como funciones

Los pasos no tienen que ser métodos de una subclase. El esqueleto puede recibirlos como parámetros: el encabezado es texto, y la fila y el total son funciones.

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,
    "pedido,suma",
    order => $"{order.Id},{order.Total:F2}",
    sum => $"total,{sum:F2}"));
Console.WriteLine(Export(orders,
    "<table>\n<tr><th>Pedido</th><th>Suma</th></tr>",
    order => $"<tr><td>{order.Id}</td><td>{order.Total:F2}</td></tr>",
    sum => $"<tr><td>Total</td><td>{sum:F2}</td></tr>\n</table>"));

Salida

pedido,suma
1001,80.00
1002,25.50
total,105.50
<table>
<tr><th>Pedido</th><th>Suma</th></tr>
<tr><td>1001</td><td>80.00</td></tr>
<tr><td>1002</td><td>25.50</td></tr>
<tr><td>Total</td><td>105.50</td></tr>
</table>

El esqueleto sigue estando en un solo lugar, y los pedidos cancelados siguen sin contar.

Esto es Strategy para cada paso: Func<Order, string> en lugar de un método abstracto. Basta para dos o tres pasos cortos. Una subclase vale la pena cuando hay muchos pasos, comparten campos o algunos son opcionales, como los ganchos Open y Close.

Problema

Todo el que quiere los pedidos pasa las páginas

Los pedidos están en un sistema que los entrega por páginas: dos por petición, porque una petición es lenta. Aquí la fuente es una lista en memoria, y cada carga imprime una línea, para que veas cuándo ocurre:

class OrderSource
{
    private readonly List<Order> orders;

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

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

El informe, el correo a los clientes y la exportación quieren todos los pedidos, y cada uno pasa las páginas por su cuenta:

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

Salida

cargando la página 1
1001
1002
cargando la página 2
1003
1004
cargando la página 3
1005
cargando la página 4

El código que solo quiere «cada pedido, uno tras otro» sabe que hay páginas, cómo se cuentan y que el final es una página vacía. Las mismas líneas están en tres archivos. Cuando el sistema pase de números de página a «una clave para la página siguiente», cambias los tres.

La idea

Iterator: recorrer algo detrás de un cursor

Quien llama quiere una sola cosa: el siguiente pedido, mientras haya uno. Cómo llegar a él (una lista, páginas, un archivo, la red) es asunto de otro.

Ese otro es el cursor: un objeto que recuerda hasta dónde llegó y responde solo a la pregunta «¿hay más?», cargando una página nueva solo cuando la anterior se acabó. Quien llama escribe un foreach común y no sabe nada de las páginas.

Este es el patrón Iterator. Tiene dos roles:

• la colección: lo que se recorre. Entrega un cursor;
• el cursor: recuerda el lugar y entrega el siguiente elemento.

Este patrón está integrado en cada uno de los cuatro lenguajes: foreach funciona con todo objeto que entregue un cursor. En C# la colección es un IEnumerable<T>, y el cursor es un IEnumerator<T> con MoveNext() y Current. El cursor no lo escribes a mano: yield return lo escribe por ti.

Míralo

El cursor que carga las páginas

yield return entrega un pedido y pausa la función justo ahí hasta que foreach pide el siguiente. Por eso la página siguiente se carga solo cuando la actual se acabó:

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

Quien llama no sabe nada de las páginas:

foreach (var order in AllOrders(source))
{
    Console.WriteLine(order.Id);
}

Salida

cargando la página 1
1001
1002
cargando la página 2
1003
1004
cargando la página 3
1005
cargando la página 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);
}

Paso a paso, en palabras

1. El bucle pide el primer pedido. Todavía no se ha cargado nada.
2. AllOrders con yield todavía no tiene página, así que carga la página 1.
3. 1001: el primer pedido de la página va al bucle, y el bucle lo imprime.
4. 1002: de la misma página. No se carga nada.
5. La página se acabó. Solo ahora el cursor carga la página 2.
6. 1003 y 1004 de la página 2.
7. Otra vez el límite: página 3.
8. 1005: la página 3 tiene un solo pedido.
9. La página 4 está vacía: no hay más pedidos.
10. El cursor dice «no hay más», y el bucle termina. El bucle nunca vio una página.

La salida es la misma, y contar las páginas está en un solo lugar. Cuando el sistema cambia la forma de entregar páginas, cambias la función con yield, y los tres lugares que recorren los pedidos no se tocan.

Míralo

Qué hace for-each por dentro

foreach es una forma corta de escribir este bucle con el cursor:

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

Salida

cargando la página 1
1001
1002
cargando la página 2
1003
1004
cargando la página 3
1005
cargando la página 4

foreach llama una vez a GetEnumerator(), y luego a MoveNext() y Current en cada paso. yield return hizo que el compilador escribiera esta clase de cursor por ti.

Pruébalo

Predice la salida

El bucle se detiene después del tercer pedido. ¿Qué imprime el programa?

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

Respuesta

cargando la página 1 / 1001 / 1002 / cargando la página 2 / 1003 / 1004

cargando la página 1 / cargando la página 2 / cargando la página 3 / cargando la página 4 / 1001 / 1002 / 1003

cargando la página 1 / 1001 / 1002 / cargando la página 2 / 1003

Comprobar

Pruébalo

Encuentra el error

El correo a los clientes primero dice cuántos pedidos hay, y luego los lista:

var orders = AllOrders(new OrderSource(all));
int count = 0;
foreach (var order in orders)
{
    count++;
}
Console.WriteLine($"Pedidos: {count}");
foreach (var order in orders)
{
    Console.WriteLine(order.Id);
}

Salida

cargando la página 1
cargando la página 2
cargando la página 3
cargando la página 4
Pedidos: 5
cargando la página 1
1001
1002
cargando la página 2
1003
1004
cargando la página 3
1005
cargando la página 4

Los números salen, pero cada página se carga dos veces, y la fuente es lenta. ¿Qué línea tienes que cambiar?

Elige la línea con el error.

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

Comprobar

La idea

Cuándo no los necesitas

Template Method tiene un costo: una clase base y herencia, y la herencia es un lazo difícil de deshacer. No vale la pena cuando:

• hay un solo formato. Una sola método sin pasos es más clara;
• hay uno o dos pasos. Pásalos como lambdas, como en la tarjeta «Sin herencia»;
• las subclases quieren cambiar también el orden de los pasos. Entonces el esqueleto no es común, y si lo fuerzas te quedan pasos con un if dentro.

No necesitas un Iterator propio cuando los datos ya están en una lista: ya se puede recorrer. Escribes uno propio cuando detrás hay algo que no es una colección en memoria: páginas, un archivo leído línea por línea, un árbol o una secuencia infinita (números de factura).

Ejercicio

Un informe en Markdown

Resuelve la tarea en tu editor.

Markdown. El sitio de documentación quiere el informe como una tabla Markdown. Escribe MarkdownReport, que escribe solo los pasos. El encabezado son dos líneas. Report y los demás informes no se tocan. Con los pedidos de la lección:

Salida

| Pedido | Suma |
|---|---|
| 1001 | 80.00 |
| 1002 | 25.50 |
| **Total** | 105.50 |

Más tareas

• Números de fila. El informe HTML numera sus filas (<td>1</td>, <td>2</td>), y los pedidos cancelados no cuentan. ¿Dónde guardas el contador: en el esqueleto o en HtmlReport?
• Los primeros N. Escribe un método con yield que entregue solo los primeros N pedidos de otro cursor. ¿Cuántas páginas se cargan para los tres primeros?
• Solo los grandes. Recorre los pedidos de la fuente y entrega solo los de más de 30 €, de nuevo sin que quien llama sepa nada de las páginas.

Test

Ponte a prueba

1. La tienda quiere el informe también en JSON. ¿Qué escribes con Template Method?

Una subclase nueva de Report que escribe los pasos; el esqueleto no se tocaUna copia del método CSV, que modificasUn if nuevo en export para cada formato

2. ¿Por qué el paso open tiene un cuerpo vacío en la clase base, mientras que header es abstracto?

open es opcional (CSV no lo usa), y un informe sin encabezado no tiene sentidoLos pasos abstractos son más rápidosPor ninguna razón, los dos podrían ser abstractos

3. Un bucle recorre los pedidos de la fuente lenta y se detiene con break en el segundo. ¿Cuántas páginas se cargan?

TodasUnaDos

4. ¿A qué llama for-each para recorrer algo?

A un método que devuelve toda la lista de una vezAl cursor del objeto: pregunta si hay un siguiente y lo tomaA los índices de 0 a size()

Comprobar

Empezar la lección de nuevo

Lecciones relacionadas

• Se basa en: Lambdas y delegados · record, switch y patrones · Patrones de diseño · Strategy
• Ejercicios sobre el tema: Patrones de diseño