Mi az absztrakt gyártási minta megvalósítása?

Az Abstract Factory minta egy interfészt biztosít az egymással kapcsolódó vagy függő objektumcsaládok létrehozásához anélkül, hogy meghatároznánk azok konkrét osztályait.

Fő komponensek:

1. Abstract Factory: Kinyilvánít egy interfészt az absztrakt termékek létrehozási műveleteire.
2. Concrete Factory: Megvalósítja az absztrakt termékek létrehozási műveleteit egy adott termékcsaládhoz.
3. Abstract Product: Kinyilvánít egy interfészt a termék típusára.
4. Concrete Product: Megvalósítja az Abstract Product interfészt egy adott termékre.
5. Client: Használja az Abstract Factory és Abstract Product interfészeket, de nem ismeri a Concrete Factory és Concrete Product részleteit.

Implementáció:

• Egy absztrakt gyár van definiálva, amely minden terméktípushoz létrehozási módszereket tartalmaz.
• Minden termékcsaládhoz egy konkrét gyár készül, amely megvalósítja az absztrakt gyár módszereit, és létrehozza a megfelelő konkrét termékeket.
• Minden terméktípushoz egy absztrakt interfész van.
• Minden konkrét termékhez egy osztály tartozik, amely megvalósítja a megfelelő interfészt.
• A klienskód egy absztrakt gyár objektumot kap, és meghívja annak módszereit a termékek létrehozásához, kizárólag a termékinterfészekkel dolgozva.

// Absztrakt gyár
public interface IAbstractFactory
{
    IAbstractProductA CreateProductA();
    IAbstractProductB CreateProductB();
}

// Konkrét gyár 1
public class ConcreteFactory1 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

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

// Konkrét gyár 2
public class ConcreteFactory2 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

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

// Absztrakt termék A
public interface IAbstractProductA
{
    string UsefulFunctionA();
}

// Konkrét termék A1
public class ConcreteProductA1 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "A1 termék eredménye.";
    }
}

// Konkrét termék A2
public class ConcreteProductA2 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "A2 termék eredménye.";
    }
}

// Absztrakt termék B
public interface IAbstractProductB
{
    string UsefulFunctionB();
    string AnotherUsefulFunctionB(IAbstractProductA collaborator);
}

// Konkrét termék B1
public class ConcreteProductB1 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "B1 termék eredménye.";
    }

    // B1 termék csak A ugyanazon variánsával működik
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"B1 eredménye együttműködve a ({result})-vel";
    }
}

// Konkrét termék B2
public class ConcreteProductB2 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "B2 termék eredménye.";
    }

    // B2 termék csak A ugyanazon variánsával működik
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"B2 eredménye együttműködve a ({result})-vel";
    }
}

// Klienskód
public class Client
{
    public void Main()
    {
        // Klienskód az absztrakt gyárral dolgozik
        Console.WriteLine("Ügyfél: Teszteli az ügyfélkódot az első gyártípussal:");
        ClientMethod(new ConcreteFactory1());
        Console.WriteLine();

        Console.WriteLine("Ügyfél: Teszteli ugyanazt az ügyfélkódot a második gyártípussal:");
        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));
    }
}