当多个处理程序都可以时选择最具体的处理程序

Question

对不起标题。

我有一个系统是面向服务架构的一部分。它接收消息并处理它们。该过程可以简单地归结为将数据从一个位置移动到另一个位置。系统做出的所有决定都可以通过检查系统始终可用的两个不同类来做出：

1. 正在处理的消息
2. 特定数据操作的配置信息（从哪里移动到哪里等）

这里是主要界面

    public interface IComponent
    {
        bool CanHandle(Message theMessage, Configuration theConfiguration);
        int Priority {get;}
    }

    public interface IComponentLocator<T>
        where T : IComponent
    {
        public LocateComponent(Message theMessage, Configuration theConfiguration);
    }

我使用 Castle Windsor 框架解决依赖倒置问题，因此我实现的一个定位器接收通过数组解析器注入的所有适当组件。

这里是：

public class InjectedComponentsLocator<T> : IComponentLocator<T>
    where T : IComponent
{
    private readonly T[] components;

    public InjectedComponentsLocator(T[] components)
    {
        this.components = components;
        this.components.OrderBy((component) => component.Priority);
    }

    public T LocateComponent(Message theMessage, Configuration theConfiguration)
    {
        List<T> candidates = this.components.Where((h) => h.CanHandle(message, configuration)).ToList();

        if (candidates.Count == 0)
        {
            throw new Exception(string.Format(Resources.UnableToLocateComponentException, typeof(T).Name));
        }
        else if (candidates.Count > 1 && candidates[0].Priority == candidates[1].Priority)
        {
            throw new Exception(string.Format(Resources.AmbiguousComponentException, candidates[0].GetType().Name, candidates[1].GetType().Name));
        }

        return candidates.First();
    }
}

现在问题。 IComponent 接口上的Priority 属性.. 我不喜欢它。实际情况是优先级应该可以通过最具体的IComponent来确定。

例如，假设我有两个组件。

    public class HandlesOneRecord : IComponent
    {
        public bool CanHandle(Message theMessage, Configuration theConfiguration)
        {
            return theMessage.BatchSize == 1;
        }
    }

    public class HandlesOneInsert : IComponent
    {
        public bool CanHandle(Message theMessage, Configuration theConfiguration)
        {
            return theMessage.BatchSize == 1 && theMessage.Action = "Insert";
        }
    }

我希望系统知道一条记录的插入消息需要选择第二条，因为它是最具体的一条。现在我需要设置不同的优先级，这感觉在创建新组件时会变得笨拙并产生错误。

添加以尝试澄清：
如果系统最终以我设想的方式工作，我将能够拥有两个组件，一个将处理任何“插入”类型的操作，还有一个特定组件将处理批量大小 = 1 的“插入”。任何开发人员写作代码不必关心系统是否选择了正确的，它只会选择正确的。

谢谢！

Answer 1

您可以通过使用评分系统来做到这一点。

public sealed class Score
{
    private int _score;

    public Score(params bool[] conditions)
    {
        foreach(bool b in conditions)
        {
           if(b)
              ++_score;
           else
           {
              _score = 0;
              break;
           }
        }
    } // eo ctor

    public int Total { get { return _score; } }
}  // eo class Score

您的IComponent 可能如下所示：

public interface IComponent
{
    Score CanHandle(Message theMessage, Configuration theConfiguration);
}  // eo IComponent

专业：

public class HandlesOneRecord : IComponent
{
    public Score CanHandle(Message theMessage, Configuration theConfiguration)
    {
        return new Score(theMessage.BatchSize == 1);
    }
}

public class HandlesOneInsert : IComponent
{
    public Score CanHandle(Message theMessage, Configuration theConfiguration)
    {
        return new Score(theMessage.BatchSize == 1, theMessage.Action == "Insert");
    }
}

然后找到最合适的处理程序，遍历并选择得分最高的处理程序。如果您有 100 多个处理程序，则可以通过为 Message 生成哈希码并将成功的查找存储在 Dictionary<int, Func<Message, Configuration, Score>> 中来提高其性能。

Answer 2

鉴于您的域已经相当面向消息，您是否考虑过使用某种消息总线，例如NServiceBus？

这些类型的基础架构具有您似乎正在寻找的消息处理管道，包括诸如基于类型分派到处理程序，甚至具有多态性以及定义处理程序顺序和每个处理程序的能力能够停止管道。

Answer 3

您似乎想根据消息中包含的数据而不是其类型来选择组件。

Specification pattern 是一个不错的可扩展选项。您可以拥有 Bob Horn 建议的责任链，其中每个组件将根据注入的规范确定它是否可以处理消息。这些方面的东西：

public abstract class Component 
{
  protected Component _next;
  protected MessageSpecification _specification;

  public Component(MessageSpecification specification)
  {
    // Inject specification here
  }

  public void Inspect(Message message)
  {
    if (_specification.IsSatisfiedBy(message))
    {
       Handle(message);
    }
    else _next.Inspect(message);
  }

  abstract void Handle(Message message);
}

在系统的其他部分，您需要：

• 定义每个具体组件和相关规范（如果有）。

• 按特定顺序组装责任链。这可以基于域规则（您可能是唯一知道的）来完成，或者，假设您的所有规范都是互斥的，将所有基于规范的组件放在链中的首位。