Именованные каналы не работают для асинхронной дуплексной связи

Почему-то я не могу заставить именованные каналы работать для дуплексной связи между клиентом и сервером для приложения .Net. Дуплексная связь работает нормально, когда я перехожу к последовательному обмену сообщениями, но когда я делаю это случайным, т. Е. Сервер и клиент могут пинговать друг друга в любое случайное время, это просто не работает.

Другие сообщения также не очень полезны - c# Full Duplex Asynchronous Named Pipes. НЕТТО

Я прилагаю свой код, как показано ниже:

-Код сервера:

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

Код клиента:

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