C# 命名管道不适用于异步双工通信

不知何故，我无法为.Net应用程序的客户端和服务器之间的双工通信获得命名管道。 当我使用顺序消息传递时，双工通信可以正常工作，但当我将其设置为随机时（即服务器和客户端可以在任意时间相互ping），双工通信就无法正常工作

其他职位也没有多大帮助——

我附上我的代码如下：

-服务器代码：

        namespace Server
        {
            class Program
            {
                static void Main(string[] args)
                {
                    var namedPipeServerStream = new NamedPipeServerStream("myPipe",
                        PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous);
                    Task.Run(() => StartListeningAsync(namedPipeServerStream, (msg) => Console.WriteLine(msg)));
                    Task.Run(() => SendMessageAsync(namedPipeServerStream));
                    Console.ReadLine();
                }

                public static async Task SendMessageAsync(NamedPipeServerStream namedPipeServer)
                {
                    using (var stream = new StreamWriter(namedPipeServer))
                    {
                        while (true)
                        {
                            await Task.Delay(2000);
                            try
                            {
                                var serialized = JsonConvert.SerializeObject($"Server {DateTime.Now}");
                                byte[] messageBytes = Encoding.UTF8.GetBytes(serialized);
                                if (!namedPipeServer.IsConnected)
                                {
                                    namedPipeServer.WaitForConnection();
                                    Console.WriteLine("Client connected");
                                }
                                await namedPipeServer.WriteAsync(messageBytes, 0, messageBytes.Length);
                                await namedPipeServer.FlushAsync();
                                namedPipeServer.WaitForPipeDrain();
                            }
                            catch (Exception exception)
                            {
                                Console.WriteLine($"Exception:{exception}");
                            }
                        }
                    }
                }

                public static async Task StartListeningAsync(NamedPipeServerStream namedPipeServer, Action<string> messageRecieved)
                {
                    while (true)
                    {
                        try
                        {

                            StringBuilder messageBuilder = new StringBuilder();
                            string messageChunk = string.Empty;
                            byte[] messageBuffer = new byte[1024];
                            do
                            {
                                if (!namedPipeServer.IsConnected)
                                {
                                    namedPipeServer.WaitForConnection();
                                    Console.WriteLine("Client connected");
                                }
                                await namedPipeServer.ReadAsync(messageBuffer, 0, messageBuffer.Length);
                                messageChunk = Encoding.UTF8.GetString(messageBuffer);
                                messageBuilder.Append(messageChunk);
                                messageBuffer = new byte[messageBuffer.Length];
                            } while (!namedPipeServer.IsMessageComplete);
                            if (messageRecieved != null)
                            {
                                messageRecieved(JsonConvert.DeserializeObject<string>(messageBuilder.ToString()));
                            }
                        }
                        catch (Exception exception)
                        {
                            Console.WriteLine($"Exception:{exception}");
                        }
                    }
                }   
            }
        }

命名空间服务器
{
班级计划
{
静态void Main（字符串[]参数）
{
var namedPipeServerStream=新的namedPipeServerStream（“myPipe”，
PipeDirection.InOut，1，PipeTransmissionMode.Message，PipeOptions.Asynchronous）；
Task.Run（（）=>StartListeningAsync（namedPipeServerStream，（msg）=>Console.WriteLine（msg））；
运行（（）=>SendMessageAsync（namedPipeServerStream））；
Console.ReadLine（）；
}
公共静态异步任务SendMessageAsync（NamedPipeServerStream namedPipeServer）
{
使用（var stream=newstreamwriter（namedPipeServer））
{
while（true）
{
等待任务。延迟（2000）；
尝试
{
var serialized=JsonConvert.serialized对象（$“Server{DateTime.Now}”）；
byte[]messageBytes=Encoding.UTF8.GetBytes（序列化）；
如果（！namedPipeServer.IsConnected）
{
namedPipeServer.WaitForConnection（）；
Console.WriteLine（“客户端连接”）；
}
等待namedPipeServer.WriteAsync（messageBytes，0，messageBytes.Length）；
等待namedPipeServer.FlushAsync（）；
namedPipeServer.WaitForPipeDrain（）；
}
捕获（异常）
{
WriteLine（$“异常：{Exception}”）；
}
}
}
}
公共静态异步任务StartListeningAsync（NamedPipeServerStream namedPipeServer，Action MessageReceived）
{
while（true）
{
尝试
{
StringBuilder messageBuilder=新建StringBuilder（）；
string messageChunk=string.Empty；
字节[]消息缓冲区=新字节[1024]；
做
{
如果（！namedPipeServer.IsConnected）
{
namedPipeServer.WaitForConnection（）；
Console.WriteLine（“客户端连接”）；
}
等待namedPipeServer.ReadAsync（messageBuffer，0，messageBuffer.Length）；
messageChunk=Encoding.UTF8.GetString（messageBuffer）；
messageBuilder.Append（messageChunk）；
messageBuffer=新字节[messageBuffer.Length]；
}而（！namedPipeServer.IsMessageComplete）；
if（messagereceived！=null）
{
MessageReceived（JsonConvert.DeserializeObject（messageBuilder.ToString（））；
}
}
捕获（异常）
{
WriteLine（$“异常：{Exception}”）；
}
}
}   
}
}

客户端代码：

            namespace Client
            {
                class Program
                {
                    static void Main(string[] args)
                    {
                        var namedPipeClientStream = new NamedPipeClientStream(".", "server", PipeDirection.InOut, PipeOptions.Asynchronous,
                                            TokenImpersonationLevel.Impersonation);
                        Task.Run(() => StartListeningAsync(namedPipeClientStream, (msg) => Console.WriteLine(msg)));
                        Task.Run(() => SendMessageAsync(namedPipeClientStream));
                        Console.ReadLine();
                    }

                    public static async Task SendMessageAsync(NamedPipeClientStream namedPipeClient)
                    {
                        using (var stream = new StreamWriter(namedPipeClient))
                        {
                            while (true)
                            {
                                try
                                {
                                    await Task.Delay(3000);
                                    var serialized = JsonConvert.SerializeObject($"Client {DateTime.Now}");
                                    byte[] messageBytes = Encoding.UTF8.GetBytes(serialized);
                                    if (!namedPipeClient.IsConnected)
                                    {
                                        namedPipeClient.Connect();
                                        namedPipeClient.ReadMode = PipeTransmissionMode.Message;
                                        Console.WriteLine("Client connected");
                                    }
                                    await namedPipeClient.WriteAsync(messageBytes, 0, messageBytes.Length);
                                    await namedPipeClient.FlushAsync();
                                    namedPipeClient.WaitForPipeDrain();
                                }
                                catch (Exception exception)
                                {
                                    Console.WriteLine($"Exception:{exception}");
                                }
                            }
                        }
                    }

                    public static async Task StartListeningAsync(NamedPipeClientStream namedPipeClient, Action<string> messageRecieved)
                    {
                        using (var streamReader = new StreamReader(namedPipeClient))
                        {
                            while (true)
                            {
                                try
                                {

                                    StringBuilder messageBuilder = new StringBuilder();
                                    string messageChunk = string.Empty;
                                    byte[] messageBuffer = new byte[1024];
                                    do
                                    {
                                        if (!namedPipeClient.IsConnected)
                                        {
                                            namedPipeClient.Connect();
                                            namedPipeClient.ReadMode = PipeTransmissionMode.Message;
                                        }
                                        await namedPipeClient.ReadAsync(messageBuffer, 0, messageBuffer.Length);
                                        messageChunk = Encoding.UTF8.GetString(messageBuffer);
                                        messageBuilder.Append(messageChunk);
                                        messageBuffer = new byte[messageBuffer.Length];
                                    } while (!namedPipeClient.IsMessageComplete);
                                    if (messageRecieved != null)
                                    {
                                        messageRecieved(JsonConvert.DeserializeObject<string>(messageBuilder.ToString()));
                                    }
                                }
                                catch (Exception exception)
                                {
                                    Console.WriteLine($"Exception:{exception}");
                                }
                            }
                        }
                    }
                }
            }

命名空间客户端
{
班级计划
{
静态void Main（字符串[]参数）
{
var namedPipeClientStream=new namedPipeClientStream（“.”，“服务器”，PipeDirection.InOut，PipeOptions.Asynchronous，
TokenImpersonationLevel.Impersonation）；
Task.Run（（）=>StartListeningAsync（namedPipeClientStream，（msg）=>Console.WriteLine（msg））；
运行（（）=>SendMessageAsync（namedPipeClientStream））；
Console.ReadLine（）；
}
公共静态异步任务SendMessageAsync（NamedPipeClientStream namedPipeClient）
{
使用（var stream=newstreamwriter（namedPipeClient））
{
while（true）
{
尝试
{
等待任务。延迟（3000）；
var serialized=JsonConvert.serialized对象（$“Client{DateTime.Now}”）；
byte[]messageBytes=Encoding.UTF8.GetBytes（序列化）；
如果（！namedPipeClient.IsConnected）
{
namedPipeClient.Connect（）；
namedPipeClient.ReadMode=PipeTransmissionMode.Message；
Console.WriteLine（“客户端连接”）；
}
等待namedPipeClient.WriteAsync（messageBytes，0，messageBytes.Length）；