五丶Client与Server实现传输（异步收包，发包，异步链接）

客户端：

逻辑部分

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Net;
using System.Net.Sockets;
using UnityEngine;
using TcpServer;
using ProtoBuf;

namespace TcpClinet
{   
    class MyClient
    {
        static byte[] data = new byte[1024];
        static Socket socketClient;
        static Message msg = new Message();
        public static void Connect(string ip,int port)
        {

            socketClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            socketClient.Connect(new IPEndPoint(IPAddress.Parse(ip), port)); 
            socketClient.BeginReceive(msg.Data, msg.StartIndex, msg.RemainSize, SocketFlags.None, ReceiveCallBack, socketClient);
        }   
            
        static void ReceiveCallBack(IAsyncResult ar)
        {   
            //            ar.AsyncState 可以获得之前传递的object
            Socket socketClient = null;
            try
            {
                socketClient = ar.AsyncState as Socket;
                int count = socketClient.EndReceive(ar);
                if (count == 0)
                {
                    //即便是空数据也不会是0，客户端不会发送空数据，  只有在结束时才有0的可能性
                    socketClient.Close();
                    return;
                }
                msg.AddCount(count);
                msg.ReadMessage();
                socketClient.BeginReceive(msg.Data, msg.StartIndex, msg.RemainSize, SocketFlags.None, ReceiveCallBack, socketClient);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                if (socketClient != null)
                {
                    socketClient.Close();
                }
            }
        }

        public static void Send(string msgStr)
        { 
            int count = socketClient.Receive(msg.Data);
            byte[] dataBytes = Encoding.UTF8.GetBytes(msgStr);
            int msgLen = msgStr.Length;
            byte[] lengthBytes = BitConverter.GetBytes(msgLen);
            byte[] newBytes = lengthBytes.Concat(dataBytes).ToArray();
            socketClient.Send(newBytes);
        }

        public static void Close()
        {
            socketClient.Close();
        }   
    }
}

Message

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using UnityEngine;

namespace TcpServer
{
    class Message
    {
        private byte[] data = new byte[1024];
        private int startIndex = 0;

        public byte[] Data
        {
            get { return data; }
        }
        public int StartIndex
        {
            get { return startIndex; }
        }
        public int RemainSize
        {
            get { return data.Length - startIndex; }
        }
        public void AddCount(int count)
        {
            startIndex += count;
            //Debug.Log("xxx");
        }   
        /// <summary>
        /// 解析数据
        /// </summary>
        public void ReadMessage()
        {
            while (true)
            {
                if (startIndex <= 4)
                {
                    return;
                }
                int count = BitConverter.ToInt32(data, 0);
                if ((startIndex - 4) >= count)
                {
                    string s = System.Text.Encoding.UTF8.GetString(data, 4, count);
                    Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);
                    startIndex -= count + 4;
                    Debug.Log(count); 
                }
                else break;
            }
        }
    }
}

服务器：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TcpServer
{
    class Message
    {
        private byte[] data = new byte[1024];
        private int startIndex = 0;

        public byte[] Data
        {
            get { return data; }
        }
        public int StartIndex
        {
            get { return startIndex; }
        }
        public int RemainSize
        {
            get { return data.Length - startIndex; }
        }
        public void AddCount(int count)
        {   
            startIndex += count;
        }   
        /// <summary>
        /// 解析数据
        /// </summary>
        public void ReadMessage()
        {
            while (true)
            {
                if (startIndex <= 4)
                {
                    return;
                }
                int count = BitConverter.ToInt32(data, 0);
                if ((startIndex - 4) >= count)
                {
                    string s = System.Text.Encoding.UTF8.GetString(data, 4, count);
                    Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);
                    startIndex -= count + 4;
                    Console.WriteLine(count  );
                }
                else break;
            }
        }  
    }
}

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

namespace TcpServer
{
    class Program
    {
        static byte[] dataBuffer = new byte[1024];
        static void Main(string[] args)
        {
            StartServerAsync();
            Console.ReadKey();
        }
        static void StartServerAsync()
        {
            Socket socketServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPAddress iPAddress = IPAddress.Parse("192.168.200.1");
            IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, 88);
            socketServer.Bind(iPEndPoint);

            socketServer.Listen(10);
            //Socket clientSocket = socketServer.Accept(); 下面支持多个客户端，改为异步， 之前c++服务器用的epoll这里似乎不需要关注
            socketServer.BeginAccept(AcceptCallBack, socketServer);
        }
        static Message msg = new Message();

        static void AcceptCallBack(IAsyncResult ar)
        {
            Socket socketServer = ar.AsyncState as Socket;
            Socket socketClient = socketServer.EndAccept(ar);

            string msgStr = "HelhelHelhel";
            SendMessage(socketClient,msgStr);

            msgStr = "Hello122";
            SendMessage(socketClient, msgStr);
            msgStr = "Hello22";
            SendMessage(socketClient, msgStr);

            msgStr = "Hello3";
            SendMessage(socketClient, msgStr);

            socketClient.BeginReceive(msg.Data, msg.StartIndex, msg.RemainSize, SocketFlags.None, ReceiveCallBack, socketClient);
            socketServer.BeginAccept(AcceptCallBack, socketServer);
        }
        static void SendMessage(Socket socketClient,string msgStr)
        {

            byte[] dataBytes = Encoding.UTF8.GetBytes(msgStr);
            int msgLen = msgStr.Length;
            byte[] lengthBytes = BitConverter.GetBytes(msgLen);
            byte[] newBytes = lengthBytes.Concat(dataBytes).ToArray();
            socketClient.Send(newBytes);
        }
        static void ReceiveCallBack(IAsyncResult ar)
        {
            //            ar.AsyncState 可以获得之前传递的object
            Socket socketClient = null;
            try
            {
                socketClient = ar.AsyncState as Socket;
                int count = socketClient.EndReceive(ar);
                if (count == 0)
                {
                    //即便是空数据也不会是0，客户端不会发送空数据，  只有在结束时才有0的可能性
                    socketClient.Close();
                    return;
                }
                msg.AddCount(count);
                msg.ReadMessage();
                socketClient.BeginReceive(msg.Data, msg.StartIndex, msg.RemainSize, SocketFlags.None, ReceiveCallBack, socketClient);
            }

            catch (Exception e)
            {
                Console.WriteLine(e);
                if (socketClient != null)
                {
                    socketClient.Close();
                }
            }
        }
    }
}