使用完成端口（IOCP）

using System;
using System.Net;
using System.Net.Sockets;

namespace JCommon.Net
{
    /// <summary>
    /// 存储客户端信息， 这个可以根据自己的实际情况来定义
    /// </summary>
    public class AsyncUserToken
    {
        public IPEndPoint EndPort;
        
        public Socket Socket;
        
        /// <summary>
        /// 连接时间
        /// </summary>
        public DateTime ConnectTime { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Net.Sockets;

namespace JCommon.Net
{
    /// <summary>
    /// 该类创建一个大缓冲区，该缓冲区可以分配给 SocketAsyncEventArgs 对象；
    /// 这使bufffer易于重用，并能防止碎片化堆内存；
    /// BufferManager 类的操作不是线程安全的。
    /// </summary>
    internal class BufferManager
    {
        private int m_numBytes;             // 字节总数
        private byte[] m_buffer;            // 字节数组
        private Stack<int> m_freeIndexPool;
        private int m_currentIndex;
        private int m_bufferSize;

        public BufferManager(int totalBytes, int bufferSize)
        {
            this.m_numBytes = totalBytes;
            this.m_currentIndex = 0;
            this.m_bufferSize = bufferSize;
            this.m_freeIndexPool = new Stack<int>();
        }

        public void InitBuffer()
        {
            this.m_buffer = new byte[this.m_numBytes];
        }

        /// <summary>
        /// 将缓冲区分配给 SocketAsyncEventArgs 对象
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool SetBuffer(SocketAsyncEventArgs args)
        {
            if (this.m_freeIndexPool.Count > 0)
            {
                args.SetBuffer(this.m_buffer, this.m_freeIndexPool.Pop(), this.m_bufferSize);
            }
            else
            {
                if (this.m_numBytes - this.m_bufferSize < this.m_currentIndex)
                {
                    return false;
                }
                args.SetBuffer(this.m_buffer, this.m_currentIndex, this.m_bufferSize);
                this.m_currentIndex += this.m_bufferSize;
            }
            return true;
        }

        /// <summary>
        /// 从 SocketAsyncEventArgs 对象回收缓冲区
        /// </summary>
        /// <param name="args"></param>
        public void FreeBuffer(SocketAsyncEventArgs args)
        {
            this.m_freeIndexPool.Push(args.Offset);
            args.SetBuffer(null, 0, 0);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Net.Sockets;

namespace JCommon.Net
{
    /// <summary>
    /// 表示可重用SocketAsyncEventArgs对象的集合
    /// </summary>
    internal class SocketAsyncEventArgsPool
    {
        private Stack<SocketAsyncEventArgs> m_pool;
        
        public SocketAsyncEventArgsPool(int capacity)
        {
            this.m_pool = new Stack<SocketAsyncEventArgs>(capacity);
        }

        public void Push(SocketAsyncEventArgs item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("Items added to a SocketAsyncEventArgsPool cannot be null");
            }
            lock (this.m_pool)
            {
                this.m_pool.Push(item);
            }
        }

        public SocketAsyncEventArgs Pop()
        {
            SocketAsyncEventArgs result;
            lock (this.m_pool)
            {
                result = this.m_pool.Pop();
            }
            return result;
        }

        public int Count
        {
            get
            {
                return this.m_pool.Count;
            }
        }
    }
}

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace JCommon.Net
{
    public class SocketClient
    {
        public event EventHandler<SocketAsyncEventArgs> OnReceived;
        public event EventHandler<SocketAsyncEventArgs> OnSendCompleted;
        public event EventHandler<SocketAsyncEventArgs> OnConnectCompleted;
        public event EventHandler<SocketAsyncEventArgs> OnConnectionClosed;

        private Socket sock;
        private byte[] sendBuffer;
        private int receiveBufferCapacity;
        private int writeBufferCapacity;
        private SocketAsyncEventArgs readArgs = new SocketAsyncEventArgs();
        private SocketAsyncEventArgs writeArgs = new SocketAsyncEventArgs();
        private SocketAsyncEventArgs connectArgs;
        private AutoResetEvent sendCompletedEvent = new AutoResetEvent(false);
        private object sync_disconn = new object();
        private byte[] receiveBuffer;

        public SocketClient(int receiveCapacity = 1024, int sendCapacity = 256)
        {
            this.receiveBufferCapacity = receiveCapacity;
            this.writeBufferCapacity = sendCapacity;
            this.sock = new Socket(SocketType.Stream, ProtocolType.Tcp);
            this.receiveBuffer = new byte[receiveCapacity];
            this.readArgs.SetBuffer(this.receiveBuffer, 0, receiveCapacity);
            this.readArgs.Completed += this.IO_Completed;
            this.readArgs.UserToken = new AsyncUserToken
            {
                Socket = this.sock
            };
            this.sendBuffer = new byte[sendCapacity];
            this.writeArgs.SetBuffer(this.sendBuffer, 0, sendCapacity);
            this.writeArgs.Completed += this.IO_Completed;
            this.writeArgs.UserToken = new AsyncUserToken
            {
                Socket = this.sock
            };
        }

        ~SocketClient()
        {
            this.Disconnect(false);
        }

        public bool Connect(bool block = true)
        {
            if (this.sock != null && this.sock.Connected)
            {
                return true;
            }
            if (this.sock == null)
            {
                this.sock = new Socket(SocketType.Stream, ProtocolType.Tcp);
                this.readArgs = new SocketAsyncEventArgs();
                this.readArgs.SetBuffer(this.receiveBuffer, 0, this.receiveBufferCapacity);
                this.readArgs.Completed += this.IO_Completed;
                this.readArgs.UserToken = new AsyncUserToken
                {
                    Socket = this.sock
                };
                this.writeArgs = new SocketAsyncEventArgs();
                this.writeArgs.SetBuffer(this.sendBuffer, 0, this.writeBufferCapacity);
                this.writeArgs.Completed += this.IO_Completed;
                this.writeArgs.UserToken = new AsyncUserToken
                {
                    Socket = this.sock
                };
            }
            if (block)
            {
                this.sock.Connect(this.ServerIP, this.ServerPort);
                if (this.sock.Connected)
                {
                    // TCP客户端开始接受服务器发送的数据
                    this.readArgs.SetBuffer(0, this.receiveBufferCapacity);
                    if (!this.sock.ReceiveAsync(this.readArgs))
                    {
                        this.ProcessReceive(this.readArgs);
                    }
                }
            }
            else
            {
                this.connectArgs = new SocketAsyncEventArgs();
                this.connectArgs.Completed += this.IO_Completed;
                this.connectArgs.UserToken = new AsyncUserToken
                {
                    Socket = this.sock
                };
                this.connectArgs.RemoteEndPoint = new IPEndPoint(IPAddress.Parse(this.ServerIP), this.ServerPort);
                if (!this.sock.ConnectAsync(this.connectArgs))
                {
                    this.ProcessConnect(this.connectArgs);
                }
            }
            return this.sock.Connected;
        }

        /// <summary>
        /// 关闭连接
        /// </summary>
        /// <param name="reuseSocket">如果关闭套接字允许重用套接字则为true</param>
        public void Disconnect(bool reuseSocket)
        {
            if (this.sock == null)
            {
                return;
            }
            if (this.sock.Connected)
            {
                try
                {
                    lock (this.sync_disconn)
                    {
                        this.sock.Shutdown(SocketShutdown.Both);
                        this.sock.Disconnect(reuseSocket);
                        this.sock.Close();
                        this.sock = null;
                    }
                }
                catch (SocketException)
                {
                    this.sock = null;
                }
                catch (Exception)
                {
                    this.sock = null;
                }
            }
        }

        public int Send(byte[] buffer)
        {
            if (this.sock == null || !this.sock.Connected)
            {
                return 0;
            }
            return this.sock.Send(buffer);
        }

        /// <summary>
        /// 发送
        /// </summary>
        /// <param name="data">要发送的字符串</param>
        /// <param name="bBlock">阻塞发送</param>
        /// <returns></returns>
        public int Send(string data, bool bBlock = true)
        {
            byte[] bytes = Encoding.Default.GetBytes(data);
            if (bBlock)
            {
                return this.sock.Send(bytes);
            }
            if (bytes.Length > this.writeBufferCapacity)
            {
                this.writeBufferCapacity = bytes.Length;
                this.sendBuffer = new byte[this.writeBufferCapacity];
            }
            Array.Copy(bytes, this.sendBuffer, bytes.Length);
            this.writeArgs.SetBuffer(0, bytes.Length);
            if (!this.sock.SendAsync(this.writeArgs))
            {
                this.ProcessSend(this.writeArgs);
            }
            return 0;
        }

        private void IO_Completed(object sender, SocketAsyncEventArgs e)
        {
            SocketAsyncOperation lastOperation = e.LastOperation;
            switch (lastOperation)
            {
            case SocketAsyncOperation.Connect:
                this.ProcessConnect(e);
                return;
            case SocketAsyncOperation.Disconnect:
                break;
            case SocketAsyncOperation.Receive:
                this.ProcessReceive(e);
                return;
            default:
                if (lastOperation == SocketAsyncOperation.Send)
                {
                    this.ProcessSend(e);
                    return;
                }
                break;
            }
            throw new ArgumentException("The last operation completed on the socket was not a receive or send");
        }

        /// <summary>
        /// 处理接收到的数据
        /// </summary>
        /// <param name="e"></param>
        private void ProcessReceive(SocketAsyncEventArgs e)
        {
            AsyncUserToken asyncUserToken = (AsyncUserToken)e.UserToken;
            if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
            {
                if (this.OnReceived != null)
                {
                    this.OnReceived(this, e);
                }
                e.SetBuffer(e.Offset, this.receiveBufferCapacity);
                if (!asyncUserToken.Socket.ReceiveAsync(e))
                {
                    this.ProcessReceive(e);
                    return;
                }
            }
            else
            {
                this.CloseClientSocket(e);
            }
        }

        /// <summary>
        /// 发送完成后调用
        /// </summary>
        /// <param name="e"></param>
        private void ProcessSend(SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success)
            {
                if (this.OnSendCompleted != null)
                {
                    this.OnSendCompleted(this, e);
                    return;
                }
            }
            else
            {
                this.CloseClientSocket(e);
            }
        }

        private void ProcessConnect(SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success)
            {
                if (this.OnConnectCompleted != null)
                {
                    this.OnConnectCompleted(this, e);
                }

                this.readArgs.SetBuffer(0, this.receiveBufferCapacity);
                if (!this.sock.ReceiveAsync(this.readArgs))
                {
                    this.ProcessReceive(this.readArgs);
                    return;
                }
            }
            else if (e.SocketError == SocketError.ConnectionRefused || e.SocketError == SocketError.HostUnreachable || e.SocketError == SocketError.TimedOut)
            {
                if (this.OnConnectCompleted != null)
                {
                    this.OnConnectCompleted(this, e);
                    return;
                }
            }
            else
            {
                this.CloseClientSocket(e);
            }
        }

        private void CloseClientSocket(SocketAsyncEventArgs e)
        {
            if (this.OnConnectionClosed != null)
            {
                this.OnConnectionClosed(this, e);
            }
            AsyncUserToken asyncUserToken = e.UserToken as AsyncUserToken;
            try
            {
                lock (this.sync_disconn)
                {
                    if (this.sock != null)
                    {
                        this.sock.Shutdown(SocketShutdown.Send);
                        this.sock.Close(200);
                        this.sock = null;
                    }
                }
            }
            catch (Exception){}
            asyncUserToken.Socket = null;
        }

        private void Dispose()
        {
            try
            {
                // 关闭socket时，单独使用socket.close()通常会造成资源提前被释放，
                // 应该在关闭socket之前，先使用shutdown进行接受或者发送的禁用，再使用socket进行释放
                this.sock.Shutdown(SocketShutdown.Both);
                this.sock.Close();
                this.sock.Dispose();
                this.sock = null;
            }
            catch (Exception){}
        }

        public string ServerIP { get; set; }

        public int ServerPort { get; set; }

        public byte[] ReceiveBuffer
        {
            get
            {
                return this.receiveBuffer;
            }
        }

        public bool Connected
        {
            get
            {
                return this.sock != null && this.sock.Connected;
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace JCommon.Net
{
    public class SocketServer
    {
        public event EventHandler<SocketAsyncEventArgs> OnReceiveCompleted;
        public event EventHandler<SocketAsyncEventArgs> OnSendCompleted;
        public event EventHandler<SocketAsyncEventArgs> OnAccept;
        public event EventHandler<SocketAsyncEventArgs> OnConnectionBreak;

        private const int opsToPreAlloc = 2;                // 读，写（不为 接受连接 accepts 分配缓冲区空间）
        private int m_numConnections;                       // 同时处理的最大连接数
        private int m_receiveBufferSize;                    // 用于每个Socket I/O 操作的缓冲区大小
        private BufferManager m_bufferManager;              // 表示用于所有套接字操作的大量可重用的缓冲区
        private Socket listenSocket;                        // 用于监听传入的连接请求的套接字
        private SocketAsyncEventArgsPool m_readWritePool;   // 可重用SocketAsyncEventArgs对象池，用于写入，读取和接受套接字操作
        private List<SocketAsyncEventArgs> m_connectedPool;
        private int m_totalBytesRead;                       // 服务器接收的总共＃个字节的计数器
        private int m_numConnectedSockets;                  // 连接到服务器的客户端总数
        private Semaphore m_maxNumberAcceptedClients;

        /// <summary>
        /// 创建服务端实例
        /// </summary>
        /// <param name="numConnections"></param>
        /// <param name="receiveBufferSize"></param>
        public SocketServer(int numConnections, int receiveBufferSize)
        {
            this.m_totalBytesRead = 0;
            this.m_numConnectedSockets = 0;
            this.m_numConnections = numConnections;
            this.m_receiveBufferSize = receiveBufferSize;
            this.m_bufferManager = new BufferManager(receiveBufferSize * numConnections * opsToPreAlloc, receiveBufferSize);
            this.m_readWritePool = new SocketAsyncEventArgsPool(numConnections);
            this.m_connectedPool = new List<SocketAsyncEventArgs>(numConnections);
        }

        /// <summary>
        /// 分配 SocketAsyncEventArg 对象池
        /// </summary>
        public void Init()
        {
            // 分配一个大字节缓冲区，所有 I/O 操作都使用该缓冲区。
            this.m_bufferManager.InitBuffer();
            for (int i = 0; i < this.m_numConnections; i++)
            {
                // 分配可重用的 SocketAsyncEventArgs 对象
                SocketAsyncEventArgs socketAsyncEventArgs = new SocketAsyncEventArgs();
                socketAsyncEventArgs.Completed += this.IO_Completed;
                socketAsyncEventArgs.UserToken = new AsyncUserToken();

                // 将缓冲池中的字节缓冲区分配给 SocketAsyncEventArg 对象
                this.m_bufferManager.SetBuffer(socketAsyncEventArgs);

                // 放入对象池
                this.m_readWritePool.Push(socketAsyncEventArgs);
            }
        }

        /// <summary>
        /// 启动服务器，侦听客户端连接请求
        /// </summary>
        /// <param name="localEndPoint"></param>
        public void Start(IPEndPoint localEndPoint)
        {
            try
            {
                // 限制最大连接数
                this.m_maxNumberAcceptedClients = new Semaphore(this.m_numConnections, this.m_numConnections);

                // 创建 Socket 监听连接请求
                this.listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                this.listenSocket.Bind(localEndPoint);
                this.listenSocket.Listen(10);

                // 接受客户端连接请求
                this.StartAccept(null);
            }
            catch (Exception){}
        }

        public void Stop()
        {
            if (this.listenSocket == null)
            {
                return;
            }
            try
            {
                lock(m_connectedPool)
                {
                    for (int i = 0; i < this.m_connectedPool.Count; i++)
                    {
                        this.CloseClientSocket(m_connectedPool[i]);
                    }
                    this.m_connectedPool.Clear();
                }
                this.listenSocket.LingerState = new LingerOption(true, 0);
                this.listenSocket.Close();
                this.listenSocket.Dispose();
                this.listenSocket = null;
                GC.Collect();
            }
            catch (Exception)
            {
            }
        }

        public void Send(AsyncUserToken arg, byte[] msg)
        {
           SocketAsyncEventArgs argSend =  this.m_connectedPool.Find((s) => {
                AsyncUserToken userToken = s.UserToken as AsyncUserToken;
                return userToken.EndPort.ToString() == arg.EndPort.ToString();
            });

           AsyncUserToken userToken1 = argSend.UserToken as AsyncUserToken;
           userToken1.Socket.Send(msg);
        }

        public void SendToAll(byte[] msg)
        {
            foreach(SocketAsyncEventArgs arg in this.m_connectedPool)
            {
                AsyncUserToken userToken = arg.UserToken as AsyncUserToken;
                userToken.Socket.Send(msg);
            }
        }

        /// <summary>
        /// 开始接受来自客户端的连接请求
        /// </summary>
        /// <param name="acceptEventArg"></param>
        private void StartAccept(SocketAsyncEventArgs acceptEventArg)
        {
            if (acceptEventArg == null)
            {
                acceptEventArg = new SocketAsyncEventArgs();
                acceptEventArg.Completed += this.AcceptEventArg_Completed;
            }
            else
            {
                acceptEventArg.AcceptSocket = null;
            }
            this.m_maxNumberAcceptedClients.WaitOne();
            if (this.listenSocket == null)
            {
                return;
            }
            if (!this.listenSocket.AcceptAsync(acceptEventArg))
            {
                this.ProcessAccept(acceptEventArg);
            }
        }

        /// <summary>
        /// 接受连接请求完成后回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void AcceptEventArg_Completed(object sender, SocketAsyncEventArgs e)
        {
            this.ProcessAccept(e);
        }

        private void ProcessAccept(SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success)
            {
                Interlocked.Increment(ref this.m_numConnectedSockets);
                if (this.OnAccept != null)
                {
                    this.OnAccept(null, e);
                }

                // 获取接受的客户端连接的套接字
                SocketAsyncEventArgs socketAsyncEventArgs = this.m_readWritePool.Pop();
                AsyncUserToken userToken = socketAsyncEventArgs.UserToken as AsyncUserToken;
                userToken.Socket = e.AcceptSocket;
                userToken.ConnectTime = DateTime.Now;
                userToken.EndPort = e.AcceptSocket.RemoteEndPoint as IPEndPoint;

                lock (m_connectedPool)
                {
                    this.m_connectedPool.Add(socketAsyncEventArgs);
                }

                if (!e.AcceptSocket.ReceiveAsync(socketAsyncEventArgs))
                {
                    this.ProcessReceive(socketAsyncEventArgs);
                }

                // 接受下一个连接请求
                this.StartAccept(e);
            }
            else
            {
                this.Stop();
            }
        }

        /// <summary>
        /// 每当套接字上的接收或发送操作完成时，就会调用此方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void IO_Completed(object sender, SocketAsyncEventArgs e)
        {
            switch (e.LastOperation)
            {
                case SocketAsyncOperation.Receive:
                    ProcessReceive(e);
                    break;
                case SocketAsyncOperation.Send:
                    ProcessSend(e);
                    break;
                default:
                    throw new ArgumentException("The last operation completed on the socket was not a receive or send");
            }      
        }

        /// <summary>
        /// 异步接收操作完成后，将调用此方法。
        /// </summary>
        /// <param name="e"></param>
        private void ProcessReceive(SocketAsyncEventArgs e)
        {
            AsyncUserToken asyncUserToken = (AsyncUserToken)e.UserToken;
            if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
            {
                Interlocked.Add(ref this.m_totalBytesRead, e.BytesTransferred);
                if (this.OnReceiveCompleted != null)
                {
                    this.OnReceiveCompleted(this, e);
                }
                e.SetBuffer(e.Offset, this.m_receiveBufferSize);
                if (!asyncUserToken.Socket.ReceiveAsync(e))
                {
                    this.ProcessReceive(e);
                    return;
                }
            }
            else
            {
                this.CloseClientSocket(e);
            }
        }

        /// <summary>
        /// 异步发送操作完成后，将调用此方法。
        /// 该方法在套接字上发出另一个接收，以读取从客户端发送的所有其他数据
        /// </summary>
        /// <param name="e"></param>
        private void ProcessSend(SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success)
            {
                if (this.OnSendCompleted != null)
                {
                    this.OnSendCompleted(null, e);
                }
                AsyncUserToken asyncUserToken = (AsyncUserToken)e.UserToken;
                if (!asyncUserToken.Socket.ReceiveAsync(e))
                {
                    this.ProcessReceive(e);
                    return;
                }
            }
            else
            {
                this.CloseClientSocket(e);
            }
        }

        private void CloseClientSocket(SocketAsyncEventArgs e)
        {
            if (this.OnConnectionBreak != null)
            {
                this.OnConnectionBreak(null, e);
            }
            AsyncUserToken asyncUserToken = e.UserToken as AsyncUserToken;
            if (asyncUserToken != null && asyncUserToken.Socket != null)
            {
                try
                {
                    asyncUserToken.Socket.Shutdown(SocketShutdown.Both);
                    asyncUserToken.Socket.Disconnect(false);
                    asyncUserToken.Socket.Close();
                    asyncUserToken.Socket = null;
                }
                catch (Exception)
                {
                }
                finally
                {
                    Interlocked.Decrement(ref this.m_numConnectedSockets);
                    this.m_maxNumberAcceptedClients.Release();
                    this.m_readWritePool.Push(e);
                    lock (m_connectedPool)
                    {
                        this.m_connectedPool.Remove(e);
                    }
                }
            }
        }
    }
}