定义接口间流程的类的设计模式名称

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

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

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

Answer 2

首先，根据你的名字，你似乎有你的听众和设备倒退。意思是说，你似乎在聆听来自听众的信号，并将其发送到似乎倒退的设备。在我看来，听众意味着听信号不发送信号。

但除此之外，我认为你在这里只是一个消息传递系统。不是直接在一起通信，而是有一个消息分派器，它接收来自一个组件的消息并将它们发送给另一个组件。如果您扩展了您拥有的设备而不是单个设备和单个监听器，则可以建立任意数量的连接。然后，您可以将传入的消息排队并根据这些连接将它们分派给侦听器。

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