En quoi consiste la mise en œuvre du pattern de la…

Le patron Abstract Factory fournit une interface pour créer des familles d'objets liés ou dépendants sans spécifier leurs classes concrètes.

Composants principaux:

Abstract Factory: Déclare l'interface pour les opérations de création de produits abstraits.
Concrete Factory: Implémente les opérations de création de produits abstraits pour une famille spécifique de produits.
Abstract Product: Déclare l'interface pour un type de produit.
Concrete Product: Implémente l'interface du produit abstrait pour un produit concret.
Client: Utilise les interfaces d'Abstract Factory et d'Abstract Product, mais ne connaît pas la Concrete Factory ni la Concrete Product.

Implémentation:

Définir une usine abstraite avec des méthodes pour créer chaque type de produit.
Pour chaque famille de produits, créer une usine concrète qui implémente les méthodes de l'usine abstraite et crée les produits concrets correspondants.
Définir une interface de produit abstrait pour chaque type de produit.
Créer une classe pour chaque produit concret qui implémente l'interface correspondante.
La partie client obtient un objet de l'usine abstraite et appelle ses méthodes pour créer des produits, en ne travaillant qu'avec les interfaces des produits.

// Usine abstraite
public interface IAbstractFactory
{
    IAbstractProductA CreateProductA();
    IAbstractProductB CreateProductB();
}

// Usine concrète 1
public class ConcreteFactory1 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

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

// Usine concrète 2
public class ConcreteFactory2 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

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

// Produit abstrait A
public interface IAbstractProductA
{
    string UsefulFunctionA();
}

// Produit concret A1
public class ConcreteProductA1 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "Le résultat du produit A1.";
    }
}

// Produit concret A2
public class ConcreteProductA2 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "Le résultat du produit A2.";
    }
}

// Produit abstrait B
public interface IAbstractProductB
{
    string UsefulFunctionB();
    string AnotherUsefulFunctionB(IAbstractProductA collaborator);
}

// Produit concret B1
public class ConcreteProductB1 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "Le résultat du produit B1.";
    }

    // Le produit B1 ne peut fonctionner qu'avec des produits A du même type
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"Le résultat du B1 collaborant avec le ({result})";
    }
}

// Produit concret B2
public class ConcreteProductB2 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "Le résultat du produit B2.";
    }

    // Le produit B2 ne peut fonctionner qu'avec des produits A du même type
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"Le résultat du B2 collaborant avec le ({result})";
    }
}

// Code client
public class Client
{
    public void Main()
    {
        // Le code client travaille avec l'usine abstraite
        Console.WriteLine("Client : Test du code client avec le premier type d'usine :");
        ClientMethod(new ConcreteFactory1());
        Console.WriteLine();

        Console.WriteLine("Client : Test du même code client avec le deuxième type d'usine :");
        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));
    }
}

En quoi consiste la mise en œuvre du pattern de la fabrique abstraite?