Question

程序接收消息列表（基本类型）。列表中的每条消息都必须根据其类型（后代类型）进行处理。但是，不同的消息需要不同的输入才能正确处理。

以下是什么技术？（我没有在编译器中检查过这段代码）

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();     
}

这一个？

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");
    }
}

如果我可以将ProcessBuilder类注入MessageProcessor（使用属性或Setter）然后调用Process，那么它会被调用什么？

什么技术是解决这个问题的最佳模式？

Answer 1

它们都是工厂方法模式的示例。唯一的区别是第二个示例在自己的静态类中有方法。

这是抽象工厂模式的一个例子：

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);
    }
 }

每个MessageProcessor都有自己的工厂类，它使用多态性。

传递ProcessBuilder来创建流程将是策略模式：

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());

最简单的解决方案是封装工厂方法：

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

如果它是一小部分类型，您可以使用一系列类型检查：

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

否则使用字典：

Dictionary<Type,MessageProcessor> processors;    

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

Answer 2

在我的理解中，工厂方法定义了要使用的类的抽象类型，但是将具体类型的创建委托给后续/实现类。 抽象工厂将为一组相应类的制造商定义一个接口。 构建器只是为了逐步构建一个对象，为调用实例提供一些控制。

Builder，Factory Method和Abstract Factory模式之间有什么区别？

2 个答案: