In cosa consiste l'implementazione del pattern di fabbrica astratta?

Паттерн Abstract Factory предоставляет интерфейс для создания семейств взаимосвязанных или взаимозависимых объектов, не специфицируя их конкретных классов.

Основные компоненты:

1. Abstract Factory: Объявляет интерфейс для операций создания абстрактных продуктов.
2. Concrete Factory: Реализует операции создания абстрактных продуктов для конкретного семейства продуктов.
3. Abstract Product: Объявляет интерфейс для типа продукта.
4. Concrete Product: Реализует интерфейс Abstract Product для конкретного продукта.
5. Client: Использует интерфейсы Abstract Factory и Abstract Product, но не знает о Concrete Factory и Concrete Product.

Реализация:

• Определяется абстрактная фабрика с методами для создания каждого типа продукта.
• Для каждого семейства продуктов создается конкретная фабрика, реализующая методы абстрактной фабрики и создающая соответствующие конкретные продукты.
• Для каждого типа продукта определяется абстрактный интерфейс продукта.
• Для каждого конкретного продукта создается класс, реализующий соответствующий интерфейс продукта.
• Клиентская часть получает объект абстрактной фабрики и вызывает ее методы для создания продуктов, работая только с интерфейсами продуктов.

// Абстрактная фабрика
public interface IAbstractFactory
{
    IAbstractProductA CreateProductA();
    IAbstractProductB CreateProductB();
}

// Конкретная фабрика 1
public class ConcreteFactory1 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

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

// Конкретная фабрика 2
public class ConcreteFactory2 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

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

// Абстрактный продукт A
public interface IAbstractProductA
{
    string UsefulFunctionA();
}

// Конкретный продукт A1
public class ConcreteProductA1 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "The result of the product A1.";
    }
}

// Конкретный продукт A2
public class ConcreteProductA2 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "The result of the product A2.";
    }
}

// Абстрактный продукт B
public interface IAbstractProductB
{
    string UsefulFunctionB();
    string AnotherUsefulFunctionB(IAbstractProductA collaborator);
}

// Конкретный продукт B1
public class ConcreteProductB1 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "The result of the product B1.";
    }

    // Продукт B1 может работать только с продуктами A того же варианта
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"The result of the B1 collaborating with the ({result})";
    }
}

// Конкретный продукт B2
public class ConcreteProductB2 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "The result of the product B2.";
    }

    // Продукт B2 может работать только с продуктами A того же варианта
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"The result of the B2 collaborating with the ({result})";
    }
}

// Клиентский код
public class Client
{
    public void Main()
    {
        // Клиентский код работает с абстрактной фабрикой
        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));
    }
}