Aká je implementácia vzoru abstraktnej továrne?

Vzorec Abstract Factory poskytuje rozhranie na vytváranie rodín spolu súvisiacich alebo závislých objektov bez špecifikácie ich konkrétnych tried.

Hlavné komponenty:

1. Abstract Factory: Vyhlasuje rozhranie pre operácie vytvárania abstraktných produktov.
2. Concrete Factory: Implementuje operácie vytvárania abstraktných produktov pre konkrétnu rodinu produktov.
3. Abstract Product: Vyhlasuje rozhranie pre typ produktu.
4. Concrete Product: Implementuje rozhranie Abstract Product pre konkrétny produkt.
5. Client: Používa rozhrania Abstract Factory a Abstract Product, ale nepozná Concrete Factory a Concrete Product.

Implementácia:

• Definuje sa abstraktná továreň s metódami na vytváranie každého typu produktu.
• Pre každú rodinu produktov sa vytvorí konkrétna továreň, ktorá implementuje metódy abstraktnej továrne a vytvára príslušné konkrétne produkty.
• Pre každý typ produktu sa definuje abstraktné rozhranie produktu.
• Pre každý konkrétny produkt sa vytvorí trieda, ktorá implementuje príslušné rozhranie produktu.
• Klientska časť získa objekt abstraktnej továrne a volá jej metódy na vytváranie produktov, pričom pracuje iba s rozhraniami produktov.

// Abstraktná továreň
public interface IAbstractFactory
{
    IAbstractProductA CreateProductA();
    IAbstractProductB CreateProductB();
}

// Konkrétna továreň 1
public class ConcreteFactory1 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

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

// Konkrétna továreň 2
public class ConcreteFactory2 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

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

// Abstraktný produkt A
public interface IAbstractProductA
{
    string UsefulFunctionA();
}

// Konkrétny produkt A1
public class ConcreteProductA1 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "The result of the product A1.";
    }
}

// Konkrétny produkt A2
public class ConcreteProductA2 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "The result of the product A2.";
    }
}

// Abstraktný produkt B
public interface IAbstractProductB
{
    string UsefulFunctionB();
    string AnotherUsefulFunctionB(IAbstractProductA collaborator);
}

// Konkrétny produkt B1
public class ConcreteProductB1 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "The result of the product B1.";
    }

    // Produkt B1 môže pracovať iba s produktmi A toho istého variantu
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"The result of the B1 collaborating with the ({result})";
    }
}

// Konkrétny produkt B2
public class ConcreteProductB2 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "The result of the product B2.";
    }

    // Produkt B2 môže pracovať iba s produktmi A toho istého variantu
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"The result of the B2 collaborating with the ({result})";
    }
}

// Klientska trieda
public class Client
{
    public void Main()
    {
        // Klientska trieda pracuje s abstraktnou továrňou
        Console.WriteLine("Client: Testing client code with the first factory type:");
        ClientMethod(new ConcreteFactory1());
        Console.WriteLine();

        Console.WriteLine("Client: Testing the same client code with the second factory type:");
        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));
    }
}