Question

我正在为TCP上的模型铁路控制器编写客户端库。服务器嵌入在控制单元中。

当客户端向服务器发送命令时，例如set(5, addr[3])，服务器以回复标头<REPLY set(5, addr[3])>响应，该命令的结果以及是否有错误。

因为所有这些东西都是异步的，所以我必须将回复与命令相匹配。（即使客户端只发送一个命令然后等待响应，也存在服务器端事件）

为了拥有一个易于理解的易于理解的库，我使用async await模式。这意味着客户端代码进行调用，如await client.Set(5, "addr", "3")，代码在服务器发回响应后继续，并且响应由客户端代码评估。

我目前正在使用IDictionary<string, EventWaitHandle>实现此操作，其中字符串是命令，并且SendeBefehlAwaitResonse(string befehl)方法await Task.Run(() => signal = e.WaitOne(timeout));等待了EventWaitHandle

有更常见的方法吗？对于 NetworkClient ，我还首先使用EventWaitHandle等待新消息发送（以及使用我的MessageDelay）属性。我发现使用无限循环调用await Task.Delay(100);可以获得更好的性能。

问题：

是否有更好的方法来等待服务器响应？也许使用 Reactive Extensions 或其他一些库？

如果我必须重写部分库，这对我来说不是什么大问题。我写这个库主要是为了学习目的。虽然代码（主要是TCP客户端）在某种程度上被黑客攻击代码，但我会尽力为项目提供更好且易于理解的结构。

提前感谢您的帮助！

您可以在此处找到代码：https://github.com/schjan/RailNet | Message Dispatcher Class

Answer 1

Rx可能会让您的生活更轻松。我还想象它会减少代码中的一些潜在竞争条件，并且最终会减少管道样式代码（即维护缓存的代码）。

如果我从我认为是代码的关键元素（来自https://github.com/schjan/RailNet/blob/master/src/RailNet.Clients.Ecos/Basic/NachrichtenDispo.cs）开始，并将它们拉出到我看到的方法中。

private bool HasBeginAndEnd(string[] message)
{
    bool isValid = true;

    if (!message[0].StartsWith("<") || !message[0].EndsWith(">"))
        isValid = false;

    if (!message.Last().StartsWith("<END"))
        isValid = false;

    return isValid;
}
private bool IsReplyMessage(string[] message)
{
    return message.Length>0 && message[0].StartsWith("<REPLY ");
}
private BasicAntwort ParseResponse(string[] message)
{
    string header = message[0].Substring(7, message[0].Length - 8);
    return new BasicAntwort(message, header);
}

使用这些漂亮的小描述方法，我可以使用Rx创建一个可观察的响应序列。

var incomingMessages = Observable.FromEventPattern<MessageReceivedEventArgs>(
    h => _networkClient.MessageReceivedEvent += h,
    h => _networkClient.MessageReceivedEvent -= h)
.Select(x => x.EventArgs.Content)
.Where(HasBeginAndEnd)
.Where(IsReplyMessage)
.Select(ParseResponse);

很酷，现在我们有一个传入的流/序列。

接下来，我们希望能够发出命令并为其返回适当的响应。 Rx也可以这样做。

incomingMessages.Where(reply=>reply.Header == befehl)

要继续，我们还想添加一个超时，这样如果我们在给定时间内没有得到out命令的响应（8000ms？），我们就应该抛出。我们可以把它转换成一个任务，如果我们只想要单个值，那么我们也可以用Rx做到这一点。

incomingMessages.Where(reply=>reply.Header == befehl)
                .Timeout(TimeSpan.FromSeconds(2))
                .Take(1)
                .ToTask();

现在差不多完成了。我们只想要一种方法来发送命令并返回响应（或超时）的任务。没问题。只需先订阅我们的传入消息序列，以避免竞争条件，然后发出命令。

public Task<BasicAntwort> SendCommand(NetworkClient networkClient, string befehl)
{
    //Subscribe first to avoid race condition.
    var result = incomingMessages
                        .Where(reply=>reply.Header == befehl)
                        .Timeout(TimeSpan.FromSeconds(2))
                        .Take(1)
                        .ToTask();

    //Send command
    networkClient.SendMessage(befehl);

    return result;
}

以下是作为LinqPad脚本的整个代码

    void Main()
    {
        var _networkClient = new NetworkClient();
        var sendCommandTask = SendCommand(_networkClient, "MyCommand");
        BasicAntwort reply = sendCommandTask.Result;
        reply.Dump();
    }


    private static bool HasBeginAndEnd(string[] message)
    {
        bool isValid = true;

        if (!message[0].StartsWith("<") || !message[0].EndsWith(">"))
            isValid = false;

        if (!message.Last().StartsWith("<END"))
            isValid = false;

        return isValid;
    }
    private static bool IsReplyMessage(string[] message)
    {
        return message.Length>0 && message[0].StartsWith("<REPLY ");
    }
    private static BasicAntwort ParseResponse(string[] message)
    {
        string header = message[0].Substring(7, message[0].Length - 8);
        return new BasicAntwort(message, header);
    }

    public IObservable<BasicAntwort> Responses(NetworkClient networkClient)
    {
        return Observable.FromEventPattern<MessageReceivedEventArgs>(
                h => networkClient.MessageReceivedEvent += h,
                h => networkClient.MessageReceivedEvent -= h)
            .Select(x => x.EventArgs.Content)
            .Where(HasBeginAndEnd)
            .Where(IsReplyMessage)
            .Select(ParseResponse);
    }   

    public Task<BasicAntwort> SendCommand(NetworkClient networkClient, string befehl)
    {
        //Subscribe first to avoid race condition.
        var result = Responses(networkClient)
                            .Where(reply=>reply.Header == befehl)
                            .Timeout(TimeSpan.FromSeconds(2))
                            .Take(1)
                            .ToTask();

        //Send command
        networkClient.SendMessage(befehl);

        return result;
    }   


public class NetworkClient
{
public event EventHandler<MessageReceivedEventArgs> MessageReceivedEvent;
public bool Connected { get; set; }
public void SendMessage(string befehl)
{
    var handle = MessageReceivedEvent;
    if(handle!=null){

        var message = new string[3]{"<REPLY " + befehl +">", "Some content", "<END>"};

        handle(this, new UserQuery.MessageReceivedEventArgs(){Content=message});
    }
}
}
public class MessageReceivedEventArgs : EventArgs
{
public string[] Content { get; set; }
}

public class BasicAntwort
{
    public BasicAntwort(string[] message, string header)
    {
        Header = header;
        Message = message;
    }

    public string Header { get; set; }
    public string[] Message { get; set; }
}

等待服务器响应同时以异步方式响应不同的呼叫

1 个答案: