异步套接字

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

namespace ConsoleApp1
{
    public class TcpSocket
    {
        private Func<string, string> fDeal;
        private IPEndPoint endPoint;
        private Socket socketServer;
        private int bufferSize = 4096;

        public TcpSocket(string ip,int port,Func<string,string> fDeal)
        {
            this.fDeal = fDeal;
            socketServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            endPoint = new IPEndPoint(IPAddress.Parse(ip), port);
            socketServer.Bind(endPoint);
            socketServer.Listen(5);
            socketServer.BeginAccept(new AsyncCallback(AcceptBack), null);
        }

        private void AcceptBack(IAsyncResult ar)
        {
            var  socketClient = default(Socket);

            try
            {
                socketClient = socketServer.EndAccept(ar);

                if (socketClient != null && socketClient.Connected)
                {
                    var buffers = new List<byte[]>();
                    var buffer = new byte[bufferSize];
                    var tuples = new Tuple<Socket, List<byte[]>>(socketClient, buffers);
                    Array.Clear(buffer, 0, bufferSize);
                    buffers.Add(buffer);
                    socketClient.BeginReceive(buffer, 0, bufferSize, SocketFlags.None, new AsyncCallback(ReceiveBack), tuples);
                }
            }
            catch { }

            socketServer.BeginAccept(new AsyncCallback(AcceptBack), null);
        }

        private void ReceiveBack(IAsyncResult ar)
        {

            var tuple = ar.AsyncState as Tuple<Socket, List<byte[]>>;
            var socketClient = tuple.Item1;
            var buffers = tuple.Item2;

            try
            {
                if (socketClient == null || socketClient.Connected == false)
                    return;

                var iReads = socketClient.EndReceive(ar);

                if(iReads >= bufferSize)
                {
                    var buffer = new byte[bufferSize];
                    var tuples = new Tuple<Socket, List<byte[]>>(socketClient, buffers);
                    Array.Clear(buffer, 0, buffer.Length);
                    buffers.Add(buffer);
                    socketClient.BeginReceive(buffer, 0, bufferSize, SocketFlags.None, new AsyncCallback(ReceiveBack), tuples);
                }
                else
                {
                    var length = (buffers.Count - 1) * bufferSize + iReads;
                    var buffer = new byte[length];
                    var less = buffers.Count - 1;

                    for (var i = 0; i < less; i++)
                        Array.Copy(buffers[i], 0, buffer, i * bufferSize, bufferSize);
                    Array.Copy(buffers[less], 0, buffer, less * bufferSize, iReads);

                    var recv = UTF8Encoding.UTF8.GetString(buffer);
                    if(string.IsNullOrWhiteSpace(recv) == false)
                    {
                        var send = fDeal?.Invoke(recv);
                        var sendBuffer = UTF8Encoding.UTF8.GetBytes(send);
                        socketClient.Send(sendBuffer);
                    }

                    socketClient.Close();
                }
            }
            catch
            {
            }
        }
    }
}