C# TCP异步通信TcpClient

服务端监听

using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleAppTcp
{
    class Program
    {
        private static readonly object _object = new object();
        static void Main(string[] args)
        {
            TcpListener listener = null;
            try
            {
                listener = new TcpListener(System.Net.IPAddress.Parse("127.0.0.1"), 9866);
                listener.Start();
                Console.WriteLine("启动监听");
                Task.Run(() =>
                {
                    while (true)
                    {
                        lock (_object)
                        {
                            listener.BeginAcceptTcpClient(new AsyncCallback((a) =>
                            {
                                TcpListener tcpListener = (TcpListener)a.AsyncState;
                                TcpClient client = tcpListener.EndAcceptTcpClient(a);
                                string ip = client.Client.RemoteEndPoint.ToString();
                                Console.WriteLine("收到客户端连接" + ip);

                                Task task = Task.Run(async () =>
                                {
                                    NetworkStream stream = client.GetStream();              
                                    while (true)
                                    {
                                        try
                                        {
                                            if (!stream.CanRead)
                                            {
                                                continue;
                                            }
                                            //收到客户端消息
                                            List<byte> list=new List<byte>();
                                            do
                                            {
                                                Memory<byte> buffer3 = new byte[200];
                                                await stream.ReadAsync(buffer3);
                                                list.AddRange(buffer3.ToArray());
                                            } while (stream.DataAvailable);
                                            string msg = Encoding.Unicode.GetString(list.ToArray());
                                            msg = msg.TrimEnd('\0','\r','\n');
                                            Console.WriteLine("收到客户端"+ ip + "消息：" + msg);
                                             
                                            //发送消息到客户端
                                            string input = "王安石变法" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
                                            Console.WriteLine("发送到" + ip + "客户端>" + input);
                                            ReadOnlyMemory<byte> buffer2 = Encoding.Unicode.GetBytes(input).AsMemory();
                                            await stream.WriteAsync(buffer2);
                                            await stream.FlushAsync();
                                        }
                                        catch (Exception ex)
                                        {
                                            Console.WriteLine("读取客户端消息异常." + ex.Message);
                                            break;
                                        }
                                        //Thread.Sleep(50);
                                    }
                                });
                            }), listener);
                        }
                        Thread.Sleep(100);
                    }
                });
            }
            catch (SocketException ex)
            {
                Console.WriteLine("监听异常" + ex);
            }
            finally
            {
                //listener?.Stop();
            }
            Console.ReadLine();


        }
    }
}

客户端代码

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleAppTcpClient
{
    /// <summary>
    /// 客户端代码
    /// </summary>
    class Program
    {

        private static readonly object obj = new object();

        /// <summary>
        /// 是否继续连接了
        /// </summary>
        static bool isContinueConnect = false;

        static void Main(string[] args)
        {
            Action action = null;

            //继续连接服务器
            Action continueConnect = () => {
                lock (obj) {
                    if (!isContinueConnect)
                    {
                        isContinueConnect = true;
                        action();
                    }                  
                }
            };

            action = () =>
          {
              TcpClient tcpClient = new TcpClient();
              tcpClient.BeginConnect(IPAddress.Parse("127.0.0.1"), 9866, a =>
               {
                   TcpClient tcpClient = null;
                   try
                   {
                       tcpClient = (TcpClient)a.AsyncState;
                       tcpClient.EndConnect(a);
                       Console.WriteLine("连接服务器成功");
                       isContinueConnect = false;

                       NetworkStream networkStream = tcpClient.GetStream();
                       Task t1 = Task.Run(async () =>
                       {
                           while (true)
                           {
                               try
                               {
                                   if (!networkStream.CanWrite)
                                   {
                                       continue;
                                   }
                                   //发送消息到服务器
                                   string input = "武松去九岭岗" + DateTime.Now.ToLongTimeString();
                                   Console.WriteLine("发送到服务器:" + input);
                                   ReadOnlyMemory<byte> buffer = Encoding.Unicode.GetBytes(input).AsMemory();
                                   await networkStream.WriteAsync(buffer);
                                   await networkStream.FlushAsync();

                                   Thread.Sleep(2000);
                               }
                               catch (Exception ex)
                               {
                                   Console.WriteLine("连接服务器异常" + ex.Message);
                                   continueConnect();
                                   break;
                               }
                           }                         
                       });
                       Task t2 = Task.Run(async () =>
                       {
                           while (true)
                           {
                               try
                               {
                                   if (!networkStream.CanRead)
                                   {
                                       continue;
                                   }
                                   //收到服务器消息
                                   List<byte> list = new List<byte>();
                                   do
                                   {
                                       Memory<byte> buffer3 = new byte[200];
                                       await networkStream.ReadAsync(buffer3);
                                       list.AddRange(buffer3.ToArray());
                                   } while (networkStream.DataAvailable);
                                   string msg = Encoding.Unicode.GetString(list.ToArray());
                                   msg = msg.TrimEnd('\0', '\r', '\n');
                                   Console.WriteLine("收到服务器消息：" + msg);
                               }
                               catch (Exception ex)
                               {
                                   Console.WriteLine("连接服务器异常" + ex.Message);
                                   continueConnect();
                                   break;
                               }
                           }                            
                       });                               
                   }
                   catch (Exception ex)
                   {
                       Console.WriteLine(ex.Message + ",10秒后重新连接");
                       Thread.Sleep(10000);
                       action();
                   }
               }, tcpClient);
          };          
            action();
            Console.ReadKey();
        }

    

    }
}