NamedPipeServerStream / NamedPipeClientStream包装器

Question

我正在为NamedPipeServerStream / NamedPipeClientStream编写一个小包装器，它完全基于Event ，与使用AsyncCallbacks相反。

我公开了几乎所有可能的同步和异步方法（连接/等待连接，写入等），所以如果消费者想要，例如，启动服务器实例并在客户端连接时发送消息，他可以完全同步路线并做一些像......

var server = new NamedPipeServer("helloWorld");
server.StartAndWait();
server.Write("Welcome!");

或像...那样的异步方式

var server = new NamedPipeServer("helloWorld);
server.ClientConnected += x => x.WriteAsync("Welcome!");
server.Start(); //Start() returns immediately

然而，我正在努力寻找一种好方法来阅读信息。 当前读取消息时，我触发MessageAvailable事件并将消息作为参数之一传递。

我只是无法想出一种实现同步读取的正确方法。

我考虑的是以下内容：

使用GetNextMessage()同步方法获取消息。 在内部，这可以通过两种不同的方式处理：

• 我可以使用所有尚未消耗的消息保留IEnumerable<Message> 。 因此，只要对方发送消息，我就会从流中读取它并将其存储在内存中，以便以后可以通过GetNextMessage() 。 优点是，一旦写入消息，它就会释放流，因此它不会阻止另一方发送其他消息。 缺点是我完全无法控制我将持有多少消息或它们的大小。 我的IEnumerable<Message>可能最终会有10GB的非消费消息，而且由于我不能强迫消费者检索消息，所以我无能为力。

• 我可以认为我只将一条消息存储在内部缓冲区中，并且只有在通过GetNextMessage()消耗了一条消息后才会再次开始读取。 如果我这样做，另一方将被阻止编写其他消息，直到前一个消息被消耗。 更确切地说，另一方可以写入直到流已满。 这可能是多个小的完整消息或一个不完整的消息。 在不完整的单个消息的情况下，我认为这是一种更糟糕的方法，因为在发送的消息的第1部分和后续部分之间，另一端可能最终断开连接并且整个消息将丢失。

为了使事情更难，在上述任何一种方法中，消费者总是有可能使用事件来接收消息（记住事件包含收到的消息），因此不需要GetNextMessage() 。 我要么必须完全停止在事件中发送消息，要么找到一种不通过事件消耗消息将事件推送到内部缓冲区的方法。 虽然我可以很容易地判断是否存在事件处理程序，但是无法知道消息是否实际在那里被处理（即，考虑实现这个消息的类并且监听该事件，但对它没有任何作用）。 我在这里看到的唯一真正的方法是从事件中删除消息，强制消费者始终调用GetNextMessage() ，但我对其他想法GetNextMessage()开放GetNextMessage() 。

任何一种方法都存在另一个问题，即如果使用WriteAsync() （或者从不同的线程使用Write() ，我无法控制消息的发送顺序。

谁能想到更好的方法来解决这个问题？

Answer 1

我建议采用以下方法。 创建界面：

public interface ISubscription : IDisposable {
    Message NextMessage(TimeSpan? timeout);
}

public class Message {

}

然后执行：

public class NamedPipeServer {        
    public void StartAndWait() {

    }

    public ISubscription StartAndSubscribe() {
        // prevent race condition before Start and subscribing to MessageAvailable
        var subscription = new Subscription(this);
        StartAndWait();
        return subscription;
    }

    public ISubscription Subscribe() {
        // if user wants to subscribe and some point after start - why not
        return new Subscription(this);
    }

    public event Action<Message> MessageAvailable;

    private class Subscription : ISubscription {
        // buffer
        private readonly BlockingCollection<Message> _queue = new BlockingCollection<Message>(
            new ConcurrentQueue<Message>());

        private readonly NamedPipeServer _server;

        public Subscription(NamedPipeServer server) {
            // subscribe to event
            _server = server;
            _server.MessageAvailable += OnMessageAvailable;
        }

        public Message NextMessage(TimeSpan? timeout) {
            // this is blocking call
            if (timeout == null)
                return _queue.Take();
            else {
                Message tmp;
                if (_queue.TryTake(out tmp, timeout.Value))
                    return tmp;
                return null;
            }
        }

        private void OnMessageAvailable(Message msg) {
            // add to buffer
            _queue.Add(msg);
        }

        public void Dispose() {
            // clean up
            _server.MessageAvailable -= OnMessageAvailable;
            _queue.CompleteAdding();
            _queue.Dispose();
        }
    }
}

然后客户端调用Subscribe或StartAndSubscribe 。

var sub = server.StartAndSubscribe();
var message = sub.NextMessage();
var messageOrNull = sub.NextMessage(TimeSpan.FromSeconds(1));
sub.Dispose();

这样，如果没有人订阅 - 你不缓冲任何消息。 如果有人订阅然后不消费 - 这是他们的问题，而不是你的问题，因为缓冲发生在他们现在拥有的订阅中。 您还可以限制_queue阻塞集合的大小，然后添加到它将阻止达到限制，阻止您的MessageAvailable事件，但我不建议这样做。