Entendo que uma das principais vantagens do Método Factory em relação ao Simple Factory é que ele não viola o Princípio SOLID Aberto-Fechado. Ou seja, o primeiro não requer modificação da instrução switch quando novos tipos são adicionados.

Há uma peça sobre a qual espero obter esclarecimentos. Se eu usasse uma fábrica simples, teria uma fábrica como esta (simplificada):

public class ObjectFactory {
    public static IObject CreateObject(ObjectTypeEnum objectType) {
        switch (objectType) {
            case TypeA:
                return ObjectA;
                break;
            case TypeB:
                return ObjectB;
                break;
            case TypeC:
                return ObjectC;
                break;
        }
    }
}

e o cliente chamaria assim:

IObject myObject = ObjectFactory.CreateObject(objectType);

A desvantagem na literatura é que o CreateObject precisará ser modificado quando novos tipos de objetos forem adicionados.

Mas com o método Factory, não estaríamos apenas movendo essa modificação da fábrica para o cliente, desta forma (código do cliente):

IObject myObject;
switch (objectType) {
            case TypeA:
                myObject = ObjectAFactory.CreateObject();
                break;
            case TypeB:
                myObject = ObjectBFactory.CreateObject();
                break;
            case TypeC:
                myObject = ObjectCFactory.CreateObject();
                break;
}

Nesse caso, o cliente precisará ser modificado toda vez que um novo tipo for adicionado, em comparação com o caso anterior, a fábrica precisaria ser modificada. Então, qual é a vantagem de um sobre o outro? Por favor, não marque isso como duplicado, observei muitos posts sobre fábricas e nenhum aborda essa distinção específica.

Existe uma solução melhor que não viole o Princípio Aberto / Fechado no lado do cliente ou da fábrica?