Factory Method und Simple Factory

Code in:JavaC#PythonJavaScript

Kurz gesagt: Eine Factory hält die Entscheidung, welche Klasse erzeugt wird, an einer Stelle: Simple Factory legt die Wahl an einen Ort, und Factory Method lässt eine Unterklasse entscheiden, welches Objekt entsteht.

Problem

Drei Stellen kennen jede Lieferart

Die Bestellung sagt, wie sie zum Kunden kommt: "address" (an die Haustür), "office" (in einer Kurierfiliale) oder "locker" (in einer Packstation). Jede Art hat eine Klasse mit eigenem Preis und eigenem Etikett:

interface IDelivery
{
    decimal Price { get; }

    string Label(string recipient);
}

class AddressDelivery : IDelivery
{
    public decimal Price => 5.90m;

    public string Label(string recipient) => $"{recipient}, an die Haustür";
}

class OfficeDelivery : IDelivery
{
    public decimal Price => 3.90m;

    public string Label(string recipient) => $"{recipient}, in einer Kurierfiliale";
}

class LockerDelivery : IDelivery
{
    public decimal Price => 2.90m;

    public string Label(string recipient) => $"{recipient}, in einer Packstation";
}

Drei Teile des Shops brauchen die Lieferung: die Kasse, die Preisvorschau und der Etikettendrucker. Jeder entscheidet selbst, welche Klasse er erzeugt:

static decimal Checkout(string type, decimal items)
{
    IDelivery delivery = type switch
    {
        "address" => new AddressDelivery(),
        "office" => new OfficeDelivery(),
        "locker" => new LockerDelivery(),
        _ => throw new ArgumentException(type),
    };
    return items + delivery.Price;
}

static decimal PreviewPrice(string type)
{
    IDelivery delivery = type switch
    {
        "address" => new AddressDelivery(),
        "office" => new OfficeDelivery(),
        "locker" => new LockerDelivery(),
        _ => throw new ArgumentException(type),
    };
    return delivery.Price;
}

static string PrintLabel(string type, string recipient)
{
    IDelivery delivery = type switch
    {
        "office" => new OfficeDelivery(),
        _ => new AddressDelivery(),
    };
    return delivery.Label(recipient);
}

Console.WriteLine($"Bestellung: {Checkout("locker", 40):F2} €");
Console.WriteLine($"Vorschau: Lieferung {PreviewPrice("locker"):F2} €");
Console.WriteLine("Etikett: " + PrintLabel("locker", "Maria"));

Ausgabe

Bestellung: 42.90 €
Vorschau: Lieferung 2.90 €
Etikett: Maria, an die Haustür

Letzten Monat kamen die Packstationen dazu. Jemand hat "locker" in der Kasse und in der Vorschau ergänzt. Der Etikettendrucker wurde davor geschrieben und hat für die Adresse ein _. Maria hat die Lieferung an eine Packstation bezahlt, und der Kurier ist zu ihrer Adresse gefahren.

Eine neue Art sind drei Änderungen, und eine wird vergessen. Die Wahl „welche Klasse für welche Art“ ist kopiert, und die Kopien wissen nichts voneinander.

Die Idee

Simple Factory: new lebt an einer Stelle

Die Wahl „welche Klasse für welche Art“ ist eine einzige Entscheidung, also lebt sie an einer Stelle: in einer Factory. Sie bekommt die Art und gibt ein neues Objekt zurück. Der Aufrufer schreibt kein new und kennt die Klasse nicht: Er bekommt das Interface.

Die Rollen:

• das Produkt: die gemeinsame Form, das Interface IDelivery;
• die konkreten Produkte: AddressDelivery, OfficeDelivery, LockerDelivery;
• die Factory: Deliveries.Create(type), die einzige Stelle, die weiß, welche Klasse zu welcher Art gehört;
• die Clients: die Kasse, die Vorschau, das Etikett. Sie fragen nur.

Das heißt Simple Factory. Es stammt nicht aus dem Buch der Gang of Four, ist aber die häufigste Form. Factory Method aus dem Buch ist etwas anderes und kommt weiter hinten in der Lektion.

Eine Regel: Eine unbekannte Art ist ein Fehler, kein stiller Standardwert. Eine Factory, die die Art nicht kennt, wirft eine Exception mit einer klaren Meldung. Sonst verschwindet der Fehler nicht, er fährt mit dem Kurier zur falschen Adresse.

Die Tabelle „Name → Strategie“ aus der Lektion zu Strategy ist dasselbe: eine Factory, die dir zu einem Stück Text ein Objekt gibt.

Sieh es dir an

Eine Factory für die drei Stellen

static class Deliveries
{
    public static IDelivery Create(string type) => type switch
    {
        "address" => new AddressDelivery(),
        "office" => new OfficeDelivery(),
        "locker" => new LockerDelivery(),
        _ => throw new ArgumentException($"Unbekannte Lieferart: {type}"),
    };
}

Die Kasse, die Vorschau und das Etikett wählen nicht mehr, sie fragen:

static decimal Checkout(string type, decimal items)
{
    return items + Deliveries.Create(type).Price;
}

static decimal PreviewPrice(string type)
{
    return Deliveries.Create(type).Price;
}

static string PrintLabel(string type, string recipient)
{
    return Deliveries.Create(type).Label(recipient);
}

Console.WriteLine($"Bestellung: {Checkout("locker", 40):F2} €");
Console.WriteLine($"Vorschau: Lieferung {PreviewPrice("locker"):F2} €");
Console.WriteLine("Etikett: " + PrintLabel("locker", "Maria"));

Ausgabe

Bestellung: 42.90 €
Vorschau: Lieferung 2.90 €
Etikett: Maria, in einer Packstation

Das Etikett ist für eine Packstation. Die Wahl steht an einer Stelle, also kann sie nicht an der Kasse stimmen und auf dem Etikett falsch sein.

Genauer, für Neugierige

Die Factory kann auch eine Tabelle sein: Dictionary<string, Func<IDelivery>> mit Werten wie () => new AddressDelivery(). Eine Tabelle ist praktisch, wenn die Arten von außen hinzukommen (jedes Modul registriert seine eigene). Ein switch ist klarer, wenn alle Arten an einer Stelle bekannt sind.

Sieh es dir an

Eine neue Art: eine Klasse und eine Zeile

Der Shop führt die Abholung im Geschäft ein: Art "pickup", kostenlos. Neu ist eine Klasse:

class PickupDelivery : IDelivery
{
    public decimal Price => 0.00m;

    public string Label(string recipient) => $"{recipient}, im Geschäft";
}

und eine Zeile in der Factory, hier hervorgehoben:

static class Deliveries
{
    public static IDelivery Create(string type) => type switch
    {
        "address" => new AddressDelivery(),
        "office" => new OfficeDelivery(),
        "locker" => new LockerDelivery(),
        "pickup" => new PickupDelivery(),
        _ => throw new ArgumentException($"Unbekannte Lieferart: {type}"),
    };
}

IDelivery home = Deliveries.Create("address");
Console.WriteLine($"{home.Label("Maria")}: {home.Price:F2} €");

IDelivery locker = Deliveries.Create("locker");
Console.WriteLine($"{locker.Label("Maria")}: {locker.Price:F2} €");

IDelivery pickup = Deliveries.Create("pickup");
Console.WriteLine($"{pickup.Label("Maria")}: {pickup.Price:F2} €");

Ausgabe

Maria, an die Haustür: 5.90 €
Maria, in einer Packstation: 2.90 €
Maria, im Geschäft: 0.00 €

IDelivery home = Deliveries.Create("address");
Console.WriteLine($"{home.Label("Maria")}: {home.Price:F2} €");

IDelivery locker = Deliveries.Create("locker");
Console.WriteLine($"{locker.Label("Maria")}: {locker.Price:F2} €");

IDelivery pickup = Deliveries.Create("pickup");
Console.WriteLine($"{pickup.Label("Maria")}: {pickup.Price:F2} €");

Schritt für Schritt, in Worten

1. Deliveries.Create("address") bekommt nur den Text aus der Bestellung. Die Factory sucht die passende Form dafür.
2. Aus der Form kommt ein neues AddressDelivery, aber home hat den Typ IDelivery: Der Aufrufer sieht nur Price und Label().
3. Dieselbe Factory, ein anderer Text: „locker“ geht an den anderen Formen vorbei und hält bei LockerDelivery.
4. Das Etikett sagt jetzt Packstation: Die Klasse wird an einer Stelle gewählt, und die Kasse, die Vorschau und das Etikett fragen alle diese Stelle.
5. Eine neue Art: die Klasse PickupDelivery und eine Zeile mehr in der Factory. Die Zeilen, die Deliveries.Create aufrufen, ändern sich nicht.
6. „pickup“ läuft durch wie jede andere Art. Die neue Art wurde an einer Stelle hinzugefügt.

Die Kasse, die Vorschau und das Etikett werden nicht angefasst. Sie erfahren von der neuen Art, wenn eine Bestellung sie verlangt.

Sieh es dir an

Unbekannte Art

Die Art kommt von außen: aus einem Formular, von der Seite eines Partners, aus einer alten Datei. Früher oder später taucht eine Art auf, die es nicht gibt:

try
{
    IDelivery delivery = Deliveries.Create("drone");
    Console.WriteLine(delivery.Label("Maria"));
}
catch (ArgumentException e)
{
    Console.WriteLine(e.Message);
}

Ausgabe

Unbekannte Lieferart: drone

Der Fehler sagt, welche Art unbekannt ist. Er wird dort abgefangen, wo die Bestellung in den Shop kommt, und der Kunde sieht eine Meldung statt eines Pakets am falschen Ort.

Und wenn die Factory kein _ hat? C# gibt nur eine Warnung aus. Das Programm lässt sich kompilieren und stürzt ab, wenn eine unbekannte Art ankommt:

static class Deliveries
{
    public static IDelivery Create(string type) => type switch
    {
        "address" => new AddressDelivery(),
        "office" => new OfficeDelivery(),
        "locker" => new LockerDelivery(),
    };
}

Fehler

warning CS8509: The switch expression does not handle all possible values of its input type (it is not exhaustive). For example, the pattern '""' is not covered.

Unhandled exception. System.Runtime.CompilerServices.SwitchExpressionException: Non-exhaustive switch expression failed to match its input.
Unmatched value was drone.

Sieh es dir an

Factory Method: die Unterklasse entscheidet

Simple Factory wählt nach Text. Manchmal richtet sich die Wahl aber nicht nach Text, sondern danach, welches Objekt fragt.

Der Verkaufsbericht wird als CSV (für die Buchhaltung) und als HTML-Tabelle (in einer E-Mail) verschickt. Beide tun dasselbe: Jedes Produkt ist eine Zeile, und am Ende steht eine Zeile „Gesamt“. Nur die Datei, in die die Zeilen geschrieben werden, ist anders:

interface IReportFile
{
    void Add(string product, decimal total);

    string Text();
}

class CsvFile : IReportFile
{
    private readonly List<string> lines = new() { "Produkt;Summe" };

    public void Add(string product, decimal total) => lines.Add($"{product};{total:F2}");

    public string Text() => string.Join("\n", lines);
}

class HtmlFile : IReportFile
{
    private readonly List<string> rows = new();

    public void Add(string product, decimal total) => rows.Add($"<tr><td>{product}</td><td>{total:F2}</td></tr>");

    public string Text() => "<table>\n" + string.Join("\n", rows) + "\n</table>";
}

Der gemeinsame Algorithmus steht in der Basisklasse. Der Schritt „eine Datei erzeugen“ ist eine abstrakte Methode, die jede Unterklasse liefert:

record Sale(string Product, decimal Total);

abstract class ReportExporter
{
    protected abstract IReportFile CreateFile();

    public string Export(List<Sale> sales)
    {
        IReportFile file = CreateFile();
        decimal overall = 0;
        foreach (var sale in sales)
        {
            file.Add(sale.Product, sale.Total);
            overall += sale.Total;
        }
        file.Add("Gesamt", overall);
        return file.Text();
    }
}

class CsvExporter : ReportExporter
{
    protected override IReportFile CreateFile() => new CsvFile();
}

class HtmlExporter : ReportExporter
{
    protected override IReportFile CreateFile() => new HtmlFile();
}

var sales = new List<Sale> { new("Kaffee", 12.50m), new("Tee", 8.00m) };
Console.WriteLine(new CsvExporter().Export(sales));
Console.WriteLine(new HtmlExporter().Export(sales));

Ausgabe

Produkt;Summe
Kaffee;12.50
Tee;8.00
Gesamt;20.50
<table>
<tr><td>Kaffee</td><td>12.50</td></tr>
<tr><td>Tee</td><td>8.00</td></tr>
<tr><td>Gesamt</td><td>20.50</td></tr>
</table>

Das ist Factory Method: Die Basisklasse ruft eine Methode auf, die das Objekt erzeugt (CreateFile()), und die Unterklasse entscheidet, welche Klasse genau.

Warum nicht eine fertige Datei hineingeben? Die Datei sammelt Zeilen. Jeder Export muss mit einer leeren Datei beginnen, also hält der Bericht keine Datei, er weiß, wie man eine neue erzeugt.

Wann genügt Simple Factory? Factory Method lohnt sich, wenn es um die Erzeugung herum einen gemeinsamen Algorithmus gibt, den die Unterklassen nicht wiederholen sollen (hier: die Zeilen und die Summe). Willst du nur ein Objekt nach Art, ohne Algorithmus drumherum, ist Simple Factory klarer. Und eine Unterklasse, die nur existiert, um ein neues Objekt zurückzugeben, ist Zeremonie. Dann gib ein Func<IReportFile> mit: new ReportExporter(() => new CsvFile()).

Probier es aus

Was kommt heraus?

Die Arten kommen aus einem Formular auf der Seite. Was gibt das Programm aus?

string[] types = { "office", "Locker", "locker" };
foreach (var type in types)
{
    try
    {
        Console.WriteLine(Deliveries.Create(type).Label("Maria"));
    }
    catch (ArgumentException e)
    {
        Console.WriteLine(e.Message);
    }
}

Antwort

Maria, in einer Kurierfiliale
Unbekannte Lieferart: Locker
Maria, in einer Packstation

Maria, in einer Kurierfiliale
Unbekannte Lieferart: Locker

Maria, in einer Kurierfiliale
Maria, in einer Packstation
Maria, in einer Packstation

Prüfen

Probier es aus

Finde den Fehler

Ein anderer Entwickler hat die Factory so geschrieben:

static class Deliveries
{
    public static IDelivery Create(string type) => type switch
    {
        "office" => new OfficeDelivery(),
        "locker" => new LockerDelivery(),
        _ => new AddressDelivery(),
    };
}

Die Bestellung kommt von der Seite eines Partners, die die Art mit großem Anfangsbuchstaben sendet:

IDelivery delivery = Deliveries.Create("Locker");
Console.WriteLine("Etikett: " + delivery.Label("Maria"));
Console.WriteLine($"Lieferung: {delivery.Price:F2} €");

Ausgabe

Etikett: Maria, an die Haustür
Lieferung: 5.90 €

Maria hat eine Packstation gewählt. Sie hat 5,90 € statt 2,90 € für die Lieferung bezahlt, und das Paket ging an ihre Adresse. In welcher Zeile steckt der Fehler?

Wähle die Zeile mit dem Fehler.

1static class Deliveries2{3 public static IDelivery Create(string type) => type switch4 {5 "office" => new OfficeDelivery(),6 "locker" => new LockerDelivery(),7 _ => new AddressDelivery(),8 };9}

Prüfen

Die Idee

Wann du es nicht brauchst

Eine Factory ist ein Sprung mehr beim Lesen: Um zu sehen, welche Klasse erzeugt wird, gehst du woandershin. Es lohnt sich nicht, wenn:

• diese Stelle immer dieselbe Klasse braucht. new OfficeDelivery() dort, wo die Lieferung immer an eine Filiale geht, ist klarer als eine Factory;
• die Art beim Schreiben des Codes bekannt ist und nicht als Daten hereinkommt (aus einer Bestellung, einer Datei, einem Formular);
• es eine Factory für die Factory gibt. DeliveryFactoryFactory bedeutet fast immer, dass eine der beiden überflüssig ist;
• eine Factory Method eine Unterklasse „für die Zukunft“ hat.

Es lohnt sich, wenn die Art als Daten hereinkommt und die Wahl der Klasse sonst an mehreren Stellen kopiert würde. Oder wenn es um die Erzeugung herum einen gemeinsamen Algorithmus gibt und nur der Schritt „welches Objekt“ anders ist.

Übung

Expresslieferung

Löse das in deinem Editor.

Expresslieferung. Der Shop führt die Expresslieferung an die Haustür ein: Art "express", 9,90 €, Etikett „…, Express an die Haustür“. Füge eine Klasse ExpressDelivery hinzu und mach sie über die Factory verfügbar. Die Kasse, die Vorschau und das Etikett werden nicht angefasst. Erzeuge eine Expresslieferung für Maria und gib sie aus wie in der Karte „Eine neue Art“:

Ausgabe

Maria, Express an die Haustür: 9.90 €

Weitere Aufgaben

• Großbuchstaben und Leerzeichen. Das Formular sendet "Locker" und " locker ". Lass die Factory sie akzeptieren und ändere nur die Factory. Unbekannte Arten müssen weiter einen Fehler ergeben.
• Ein JSON-Bericht. Füge dem Bericht aus der Karte „Factory Method“ ein JSON-Format hinzu: [{"product": "Kaffee", "total": 12.50}, …]. Welche Klassen schreibst du, und welche fasst du nicht an?
• Preis nach Gewicht. Packstationen nehmen Pakete bis 20 kg, und über 5 kg kostet die Lieferung an die Haustür mehr. Wohin gehört das Gewicht: in die Factory oder in die Preismethode? Überlege, warum.

Test

Teste dich

1. Der Shop führt Drohnenlieferung ein, Art "drone". Was schreibst du mit Simple Factory?

Eine neue Klasse und eine Zeile in der Factory; die Aufrufer werden nicht angefasstEine neue Klasse und eine neue Zeile im switch der Kasse, der Vorschau und des EtikettsEine neue Factory-Methode für jede Art

2. Die Factory bekommt eine Art, die sie nicht kennt. Was soll sie tun?

null zurückgeben und den Aufrufer damit umgehen lassenEine Exception mit einer klaren Meldung werfen, welche Art unbekannt istEine Lieferung an die Haustür zurückgeben, weil sie die häufigste ist

3. Wann ist Factory Method besser als Simple Factory?

Immer, weil es aus dem Buch kommtWenn die Basisklasse einen gemeinsamen Algorithmus hat und die Unterklasse nur entscheidet, welches Objekt erzeugt wirdWenn es mehr als drei Arten gibt

4. Um Speicher zu sparen, hält die Factory für jede Art ein Objekt und gibt es bei jedem create zurück. Das Objekt hält den Empfänger in einem Feld. Was passiert bei zwei Packstation-Bestellungen hintereinander?

Beide Bestellungen halten dasselbe Objekt: Die zweite ändert auch den Empfänger der erstenNichts, jede Bestellung hat ihr eigenes ObjektDas Programm lässt sich nicht kompilieren

5. Wann brauchst du keine Factory?

Wenn die Art als Text aus der Bestellung kommtWenn diese Stelle immer dieselbe Klasse brauchtWenn die Wahl der Klasse an drei Stellen steht

Prüfen

Lektion von vorn beginnen

Verwandte Lektionen

• Baut auf: Dictionary und HashSet · record, switch und Muster · Entwurfsmuster · Strategy
• Geht weiter in: Builder · Der Shop: welches Muster wohin
• Aufgaben zum Thema: Entwurfsmuster