Worin besteht die Implementierung des Abstract…

Das Abstract Factory-Muster stellt eine Schnittstelle bereit, um Familien verwandter oder abhängiger Objekte zu erstellen, ohne ihre konkreten Klassen zu spezifizieren.

Hauptkomponenten:

Abstract Factory: Deklariert die Schnittstelle für die Erstellung abstrakter Produkte.
Concrete Factory: Implementiert die Operationen zur Erstellung abstrakter Produkte für eine konkrete Produktfamilie.
Abstract Product: Deklariert die Schnittstelle für einen Produkttyp.
Concrete Product: Implementiert die Schnittstelle des abstrakten Produkts für ein konkretes Produkt.
Client: Verwendet die Schnittstellen von Abstract Factory und Abstract Product, kennt aber nicht die Concrete Factory und das Concrete Product.

Implementierung:

Es wird eine abstrakte Fabrik mit Methoden zur Erstellung jedes Produkttyps definiert.
Für jede Produktfamilie wird eine konkrete Fabrik erstellt, die die Methoden der abstrakten Fabrik implementiert und die entsprechenden konkreten Produkte erstellt.
Für jeden Produkttyp wird eine Schnittstelle für das abstrakte Produkt definiert.
Für jedes konkrete Produkt wird eine Klasse erstellt, die die entsprechende Schnittstelle implementiert.
Der Client erhält ein Objekt der abstrakten Fabrik und ruft deren Methoden zur Produkterstellung auf, wobei nur mit den Produkt-Schnittstellen gearbeitet wird.

// Abstrakte Fabrik
public interface IAbstractFactory
{
    IAbstractProductA CreateProductA();
    IAbstractProductB CreateProductB();
}

// Konkrete Fabrik 1
public class ConcreteFactory1 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

    public IAbstractProductB CreateProductB()
    {
        return new ConcreteProductB1();
    }
}

// Konkrete Fabrik 2
public class ConcreteFactory2 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

    public IAbstractProductB CreateProductB()
    {
        return new ConcreteProductB2();
    }
}

// Abstraktes Produkt A
public interface IAbstractProductA
{
    string UsefulFunctionA();
}

// Konkretes Produkt A1
public class ConcreteProductA1 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "Das Ergebnis des Produkts A1.";
    }
}

// Konkretes Produkt A2
public class ConcreteProductA2 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "Das Ergebnis des Produkts A2.";
    }
}

// Abstraktes Produkt B
public interface IAbstractProductB
{
    string UsefulFunctionB();
    string AnotherUsefulFunctionB(IAbstractProductA collaborator);
}

// Konkretes Produkt B1
public class ConcreteProductB1 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "Das Ergebnis des Produkts B1.";
    }

    // Produkt B1 kann nur mit Produkten A desselben Typs zusammenarbeiten
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"Das Ergebnis des B1, das mit ({result}) zusammenarbeitet";
    }
}

// Konkretes Produkt B2
public class ConcreteProductB2 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "Das Ergebnis des Produkts B2.";
    }

    // Produkt B2 kann nur mit Produkten A desselben Typs zusammenarbeiten
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"Das Ergebnis des B2, das mit ({result}) zusammenarbeitet";
    }
}

// Client-Code
public class Client
{
    public void Main()
    {
        // Client-Code arbeitet mit der abstrakten Fabrik
        Console.WriteLine("Client: Testen des Client-Codes mit dem ersten Fabriktyp:");
        ClientMethod(new ConcreteFactory1());
        Console.WriteLine();

        Console.WriteLine("Client: Testen des gleichen Client-Codes mit dem zweiten Fabriktyp:");
        ClientMethod(new ConcreteFactory2());
    }

    public void ClientMethod(IAbstractFactory factory)
    {
        var productA = factory.CreateProductA();
        var productB = factory.CreateProductB();

        Console.WriteLine(productB.UsefulFunctionB());
        Console.WriteLine(productB.AnotherUsefulFunctionB(productA));
    }
}

Worin besteht die Implementierung des Abstract Factory Patterns?