Quelle est la différence entre le motif d'usine et l'usine abstraite?

Ayant finalement commencé sérieusement à essayer d'apprendre certains motifs de base (très tard dans la carrière, mais c'est une histoire différente), j'essaie de comprendre les différences entre Factory Pattern et Abstract Factory.

Quelles sont les principales différences entre ces deux modèles?

Je comprends que la méthode Factory crée des objets par héritage et Abstract Factory le fait par la composition d’objets, mais d’un point de vue pratique, j’ai toujours du mal à visualiser exactement comment ils fonctionnent.

La méthode d'usine est généralement classée dans une instruction switch dans laquelle chaque cas renvoie une classe différente, à l'aide de la même interface racine, de sorte que le code appelant n'a jamais à prendre de décision concernant l'implémentation.

Imaginez une usine de validateur de carte de crédit qui renvoie un validateur différent pour chaque type de carte.

public ICardValidator GetCardValidator (string cardType)
{
    switch (cardType.ToLower())
    {
        case "visa":
            return new VisaCardValidator();
        case "mastercard":
        case "ecmc":
            return new MastercardValidator();
        default:
            throw new CreditCardTypeException("Do not recognise this type");
    }
}

Dans Abstract Factory, vous disposez de plusieurs classes d’usines concrètes (et non de méthodes Factory) dérivées d’une interface unique, qui peuvent renvoyer de nombreux types différents à partir de méthodes différentes.

Pensez à un gestionnaire de jeu d'échecs avec une classe différente pour chaque ensemble de règles de variantes.

public class StandardChessRulesFactory : IChessRulesFactory
{
    public IBoardMapper GetBoardMapper()
    {
        return new StandardChessBoardMapper();
    }

    public IKingMover GetKingMover()
    {
        return new StandardChessKingMover();
    }

    public IMoveClock GetMoveClock()
    {
        return new StandardMoveClock();
    }
}

public class HexagonalChessRulesFactory : IChessRulesFactory
{
    public IBoardMapper GetBoardMapper()
    {
        return new HexagonalChessBoardMapper();
    }

    public IKingMover GetKingMover()
    {
        return new HexagonalChessKingMover();
    }

    public IMoveClock GetMoveClock()
    {
        return new StandardMoveClock();
    }
}

public class SpeedChessRulesFactory : IChessRulesFactory
{
    public IBoardMapper GetBoardMapper()
    {
        return new StandardChessBoardMapper();
    }

    public IKingMover GetKingMover()
    {
        return new StandardChessKingMover();
    }

    public IMoveClock GetMoveClock()
    {
        return new SpeedChessMoveClock();
    }
}

Une usine abstraite, à la manière d'une stratégie, est souvent sélectionnée à l'aide d'une méthode d'usine, mais il n'est pas nécessaire de les combiner, c'est donc son propre motif.