.net - ejercicios - ¿Cuáles son las diferencias entre los patrones Builder, Factory Method y Abstract Factory?

patron de diseño abstract factory c# ejemplo

Question

Un programa recibe una lista de mensajes (tipo de base). Cada mensaje en la lista debe ser procesado de acuerdo a su tipo (tipo de descendiente). Sin embargo, diferentes mensajes necesitan diferentes entradas para ser procesados ​​correctamente.

¿Cómo se llama la siguiente técnica? (No he comprobado este código en un compilador)

abstract class MessageProcessor
{
    public static MessageProcessor GetProcessor(Message message, DataDomain data)
    {
        if (message.GetType() == typeof(FooMessage))
        {
            return new FooMessageProcessor(message, data.Name, data.Classification);

        }
        else if (message.GetType() == typeof(BarMessage))
        {
            return new BarMessageProcessor(message, data.AccountNo, data.CreditLimit);

        }
        else
            throw new SomeException("Unrecognized type");

    }

    public abstract void Process();     
}

¿Y éste?

static class MessageProcessorFactory
{
    public static MessageProcessor GetProcessor(Message message, DataDomain data)
    {
        if (message.GetType() == typeof(FooMessage))
        {
            return new FooMessageProcessor(message, data.Name, data.Classification);

        }
        else if (message.GetType() == typeof(BarMessage))
        {
            return new BarMessageProcessor(message, data.AccountNo, data.CreditLimit);

        }
        else
            throw new SomeException("Unrecognized type");
    }
}

¿Y cómo se llama si puedo inyectar la clase ProcessBuilder en un MessageProcessor (usando una propiedad o Setter) y luego llamar a Process?

¿Qué técnica sería el mejor patrón para resolver este problema?

Answer 1

Ambos son ejemplos del patrón de método de fábrica . La única diferencia es que el segundo ejemplo tiene el método en su propia clase estática.

Este sería un ejemplo del patrón abstracto de fábrica :

abstract class MessageProcessorFactory
 { public abstract MessageProcessor GetProcessor
                                     (Message message, DataDomain data);
 }

class FooMessageProcessorFactory :  MessageProcessorFactory
 { public override MessageProcessor GetProcessor
                                     (Message message, DataDomain data)
    { return new FooMessageProcessor(data.Name, data.Classification);
    }
 }

Cada MessageProcessor obtiene su propia clase de fábrica que hace uso del polimorfismo.

Pasar un ProcessBuilder para crear el proceso sería el patrón de estrategia :

class MessageProcessor
 { ProcessBuilder builder;

   public MessageProcessor(ProcessBuilder builder)
    { this.builder = builder;
    }

   public void Process()
    { builder.BuildMessage();
      builder.BuildProcess();
      builder.Process();
    }
 }

var mp = new MessageProcessor(new FooProcessBuilder());

La solución más simple sería encapsular un método de fábrica:

static void Process(Message msg, DataDomain data)
 { var p = getProcessor(msg.GetType());
   p.Process(msg, data);
 }

Si se trata de una pequeña cantidad conocida de tipos, puede usar la serie de comprobaciones de tipo:

private static MessageProcessor getProcessor(Type msgType)
 { return   (msgType == typeof(FooMessage)) ? new FooMessageProcessor()
          : (msgType == typeof(BarMessage)) ? new BarMessageProcessor()
          :                                   new DefaultMessageProcessor();
 }

De lo contrario, use un diccionario:

Dictionary<Type,MessageProcessor> processors;    

private static MessageProcessor getProcessor(Type msgType) 
 { return processors[msgType];
 }

Answer 2

En mi opinión , el método de la fábrica defnies el tipo abstracto de clase con el que trabajar, pero delega la creación del tipo concreto a las clases posteriores / implementadoras. La fábrica abstracta definiría una interfaz para un fabricante de un conjunto de clases correspondientes. Un constructor funciona simplemente para construir un objeto paso a paso, dando cierto control a la instancia de llamada.