Question

我有两个接口，彼此没有意识到。

public interface IListener
{
    event SignalEventHandler SignalReceived;
}

public interface IDevice
{
    Task HandleSignalAsync();
}

我不想让每个侦听器直接调用设备或将侦听器传递给设备实现，而是希望将它们分离并分别定义流程。例如：

public class MyApplicationFlow
{
    private readonly IListener _listener;
    private readonly IDevice _device;

    public MyApplicationFlow(IListener listener, IDevice device)
    {
        _listener = listener;
        _device = device;

        _listener.SignalReceived += ListenerOnSignalReceived;
    }

    private async void ListenerOnSignalReceived(object sender, SignalEventArgs args)
    {
        try
        {
            await _device.HandleSignalAsync();
            // do more stuff in real scenario

            args.ProgressReporter.ReportComplete();
        }
        catch (Exception ex)
        {
            args.ProgressReporter.ReportError(ex);
        }
    }
}

可能会有几个IDevice和IListener实现传入流程。

侦听器和设备似乎遵循适配器模式。但是MyApplicationFlow呢？

A Mediator定义组件之间的交互，但这里的对象是不同的类型，并且不知道父类。
A Facade封装了几个子系统，但这里没有隐藏子系统;它们被注入构造函数中。

我甚至不确定这是行为模式还是结构模式。

是否有定义对象之间流的类的通用名称？我可以使用的东西作为遵循此模式的类名的后缀，例如Manager，Coordinator，Connector（最好是.NET框架中已经使用过的东西）。

或者，因为我找不到任何东西，我是不是在叫错树？有没有更好的方法来实现这种脱钩？

Answer 1

首先，基于你的名字，你似乎有你的倾听者和设备倒退。这意味着，您似乎正在侦听从侦听器发送的信号并将其发送到似乎倒退的设备。在我看来，听众意味着听不发信号的信号。

但我认为你在这里只是一个消息传递系统。您可以使用消息调度程序从一个组件接收消息并将其发送给另一个组件，而不是直接通信。如果扩展您拥有的内容而不是单个设备和单个侦听器，则可以建立任意数量的连接。然后，您将对传入的消息进行排队，并根据这些连接将它们分发给侦听器。

interface IListener {
  void send(ISender sender, IMessage message);
}
interface ISender { }
interface IMessage { }
interface IPending {
  ISender from;
  IMessage message;
}

class Dispatcher {
  private Queue<IPending> messages = new Queue<IPending>();
  private Dictionary<ISender, List<IListener>> connections = new Dictionary<ISender, List<IListener>>();

  public void connect(ISender sender, IListener listener) {
    if (connections[sender] == null) {
      connections[sender] = new List<IListener>();
    }

    connections[sender].add(listener);
  }

  public void remove(ISender sender, IListener listener) { ... } // removes connection from connections

  public void send(ISender from, IMessage message) {
    messages.push({ from, message });
  }

  public void next() { // called in a loop, perhaps in a background thread
    if (messages.peek()) {
      var message = messages.pop();
      foreach(var listener in connections[message.from]) {
        listener.send(sender, message);
      }
    }
  }
}

Answer 2

我的第一个想法是它听起来像观察者模式的变体，除了在你的情况下观察者没有直接观察。我发现这个名为Event / Emitter / Target的变种听起来非常接近。 https://github.com/millermedeiros/js-signals/wiki/Comparison-between-different-Observer-Pattern-implementations

编辑 - 我实际上改变了主意。这是pub-sub消息传递。 IDevice类正在发送，中间类正在接收消息，而IListener正在订阅。

用于定义接口之间流的类的设计模式名称

2 个答案: