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

程序接收消息列表（基本类型）。列表中的每条消息必须根据其类型（后代类型）进行处理。但是，不同的消息需要不同的输入才能正确处理。Builder，Factory Method和Abstract Factory模式之间有什么区别？

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

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，那叫什么？

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

来源

2008-10-08 ilitirit

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

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

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

来源

2008-10-08 17:11:54

我会这样做，但我只是使用DataDomain对象作为示例。在我们的应用程序中，没有封装所有输入值的类型，并且在某些情况下，这意味着将参数传递给一个方法不需要它。 – ilitirit 2008-10-08 20:39:41

在我的理解工厂方法 defnies抽象类型类，其中与代表，但具体类型的创建工作，随后/实现类。 抽象工厂将为一组相应类的制造商定义一个接口。 A 构建器只是简单地构建一个对象，一步一步地对调用实例进行一些控制。

来源

2008-10-08 21:07:56 DaSteph

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

回答

相关问题