对于多个方法（所有方法都接受不同的派生类作为参数），正确的 C# 设计模式是什么？

Question

我有一个基类：

class Message

和两个派生类：

class SimpleMessage : Message
class ComplexMesssage : Message

这些类型在代码的另一部分中使用，如下所示：

void ProcessSimpleMessage(SimpleMessage m)
void ProcessComplexMessage(ComplexMessage m)

这些方法不在 Message 类内部，因为处理不是消息的一部分。

现在，我想避免使用 if/else/switch 结构，因为消息有很多类型。这里使用的最佳设计模式是什么？

一种选择是使用策略模式进行封装（至少按照我的理解）：

class ProcessableMessage
{
delegate void ProcessMessageDelegate(Message m)

private Message m;
private ProcessMessageDelegate ProcessMessage;
}

但是让所有处理方法接受基本类型 Message 并在内部进行强制转换真的是最佳实践吗？ 另一个问题是消息的动态类型（简单或复杂）实际上存储在此类中的两个位置 - 消息和处理算法，这看起来有点丑陋。

还有更好的解决方案吗？

谢谢!!
阿萨夫

Answer 1

我会在这里使用访客模式：

public interface IMessageVisitor
{
    void VisitSimple(SimpleMessage msg);
    void VisitComplex(ComplexMessage msg);
}

public abstract class Message
{
    public abstract void Accept(IMessageVisitor visitor);
}

public class SimpleMessage : Message
{
    public override void Accept(IMessageVisitor visitor)
    {
        visitor.VisitSimple(this);
    }
}

public class ComplexMessage : Message
{
    public override void Accept(IMessageVisitor visitor)
    {
        visitor.VisitComplex(this);
    }
}

public class MessageProcessor : IMessageVisitor
{
    void IMessageVisitor.VisitSimple(SimpleMessage msg)
    { process simple message }

    void IMessageVisitor.VisitComplex(ComplexMessage msg)
    { process complex message }

    public void Process(Message msg)
    {
        msg.Accept(this);
    }
}

Answer 2

为什么不直接添加虚拟方法：

class Message
{
    public abstract void Process();
}

如果您确实需要将代码分开：

class Message
{
    public abstract void Process();
}

class SimpleMessage
{
    public override void Process()
    {
        new SimpleMessageProcessor().Process();
    }
}

class SimpleMessageProcessor
{
    internal void Process()
    {
        // ...
    }
}

我的意思是，我们这里需要什么样的灵活性？还涉及哪些其他类别？您周围的场景是什么？在没有任何其他上下文的情况下，这确实是最容易理解、也最容易实现的方法。有时，人们会在确实不需要的时候添加一些设计缺陷。

策略模式通常适用于如果您希望使用不同的方法来处理相同的消息类型，并希望在运行时切换它们。如果一种类型的处理通常与一种类型的消息一起使用，那么您不需要使其变得更加复杂。

Answer 3

我喜欢上面的访客方法。不过，只是为了好玩，我展示了如何在 VS2008 和 VS2010 中使用 T4 减少代码冗余。

冗余来自于每条消息都需要一个 Visit 方法。此外，每个方法都需要一个简单但冗余的 Accept 实现。更接近“不要重复自己”的一种方法是使用 T4 生成代码。

为了测试以下示例，请在 VS 中添加一个类，但将扩展名从 .cs 更改为 .tt。您现在将获得两个文件：.tt 文件和连接到 .tt 文件的 .cs 文件。

.tt 文件是生成.cs 文件的模板。当时它们是相同的。

使用它作为 .tt 文件的内容：

<#@ template language="C#" #>
<#
   // On VS2008 change C# above to C#v3.5

   // -----------------------------------------------------
   // Here we declare our different message types
   var messageTypes = new []
      {
         "Simple",
         "Complex",
         "Other",
      };
   // -----------------------------------------------------
#>

namespace MessageProcessor
{
   partial interface IMessageVisitor
   {
<#
   // Let's generate all message visitor methods
   foreach (var messageType in messageTypes)
   {
#>
      void Visit (<#=messageType#>Message message);
<#
   }
#>
   }
   abstract partial class Message
   {      
      public abstract void Accept (IMessageVisitor visitor);
   }
<#
   // Let's generate all message types
   foreach (var messageType in messageTypes)
   {
#>
   sealed partial class <#=messageType#>Message : Message
   {      
      public override void Accept (IMessageVisitor visitor)
      {
         visitor.Visit (this);
      }
   }
<#
   }
#>
}

这应该生成一个如下所示的 CS 文件：

namespace MessageProcessor
{
   partial interface IMessageVisitor
   {
      void Visit (SimpleMessage message);
      void Visit (ComplexMessage message);
      void Visit (OtherMessage message);
   }
   abstract partial class Message
   {      
      public abstract void Accept (IMessageVisitor visitor);
   }
   sealed partial class SimpleMessage : Message
   {      
      public override void Accept (IMessageVisitor visitor)
      {
         visitor.Visit (this);
      }
   }
   sealed partial class ComplexMessage : Message
   {      
      public override void Accept (IMessageVisitor visitor)
      {
         visitor.Visit (this);
      }
   }
   sealed partial class OtherMessage : Message
   {      
      public override void Accept (IMessageVisitor visitor)
      {
         visitor.Visit (this);
      }
   }
}

为什么这不那么冗余？因为现在每当我想添加新消息时，我只需将其添加到模板中：

   var messageTypes = new []
      {
         "Simple",
         "Complex",
         "Other",
         "YetAnotherOne",
      };

需要注意的是，所有消息都是部分生成的，因为我们需要不同的消息负载。这是在另一个文件中指定的，它可能如下所示：

   partial class SimpleMessage
   {
      public string Name;
   }

   partial class ComplexMessage
   {
      public XmlDocument Xml;
   }

对于那些喜欢 T4 声音的人，请查看此博客：http://www.olegsych.com/2008/09/t4-tutorial-creatating-your-first-code-generator/