Care este implementarea pattern-ului fabricii…

Modelul Abstract Factory oferă o interfață pentru crearea familiilor de obiecte interdependente sau dependente, fără a specifica clasele concrete ale acestor obiecte.

Componentele principale:

Abstract Factory: Declarează o interfață pentru operațiile de creare a produselor abstracte.
Concrete Factory: Implementează operațiile de creare a produselor abstracte pentru o anumită familie de produse.
Abstract Product: Declarează o interfață pentru tipul de produs.
Concrete Product: Implementează interfața Abstract Product pentru un anumit produs.
Client: Utilizează interfețele Abstract Factory și Abstract Product, dar nu cunoaște despre Concrete Factory și Concrete Product.

Implementare:

Se definește o fabrică abstractă cu metode pentru crearea fiecărui tip de produs.
Pentru fiecare familie de produse se creează o fabrică concretă care implementează metodele fabricii abstracte și creează produsele concrete corespunzătoare.
Pentru fiecare tip de produs se definește o interfață abstractă.
Pentru fiecare produs concret se creează o clasă care implementează interfața corespunzătoare.
Codul client primește un obiect de fabrică abstractă și apelează metodele acesteia pentru a crea produsele, lucrând doar cu interfețele produselor.

// Fabrica abstractă
public interface IAbstractFactory
{
    IAbstractProductA CreateProductA();
    IAbstractProductB CreateProductB();
}

// Fabrica concretă 1
public class ConcreteFactory1 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

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

// Fabrica concretă 2
public class ConcreteFactory2 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

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

// Produsul abstract A
public interface IAbstractProductA
{
    string UsefulFunctionA();
}

// Produsul concret A1
public class ConcreteProductA1 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "Rezultatul produsului A1.";
    }
}

// Produsul concret A2
public class ConcreteProductA2 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "Rezultatul produsului A2.";
    }
}

// Produsul abstract B
public interface IAbstractProductB
{
    string UsefulFunctionB();
    string AnotherUsefulFunctionB(IAbstractProductA collaborator);
}

// Produsul concret B1
public class ConcreteProductB1 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "Rezultatul produsului B1.";
    }

    // Produsul B1 poate lucra doar cu produsele A ale aceleiași variante
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"Rezultatul B1 colaborând cu ({result})";
    }
}

// Produsul concret B2
public class ConcreteProductB2 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "Rezultatul produsului B2.";
    }

    // Produsul B2 poate lucra doar cu produsele A ale aceleiași variante
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"Rezultatul B2 colaborând cu ({result})";
    }
}

// Codul client
public class Client
{
    public void Main()
    {
        // Codul client lucrează cu fabrica abstractă
        Console.WriteLine("Client: Testarea codului client cu primul tip de fabrică:");
        ClientMethod(new ConcreteFactory1());
        Console.WriteLine();

        Console.WriteLine("Client: Testarea aceluiași cod client cu al doilea tip de fabrică:");
        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));
    }
}

Care este implementarea pattern-ului fabricii abstracte?