SocketTcpServer

自定义SocketTcpServer，虽然现在有很多这样的组件，但是有时候还是需要把它集成在你的框架或者产品中，不需要特别强大的功能，根据需求定制。最基本的一个问题是判断数据包的结束，没有像supersocket那样默认以换行作为一个命令的结束，如果需要可以改善。

    public interface ISocketTcpServer
    {
        void Listen();
        void Stop();
        void SendData(byte[] data, Socket client);

        event ReceiveDataHandler ReceivedDataEvent;
        event OnlineChangeHandler OnlineChangeEvent;
        event ErrorHandler ErrorEvent;
    }

    public delegate void ReceiveDataHandler(SocketState state);

    public delegate void OnlineChangeHandler(int onlines, EndPoint client);

    public delegate void ErrorHandler(string error, EndPoint client);

    public class SocketTcpServer : ISocketTcpServer
    {
        private readonly Socket _tcpSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        public readonly EndPoint LocalPoint;
        public readonly List<SocketState> ClientList = new List<SocketState>();
        public bool IsListening;

        public SocketTcpServer(IPEndPoint localPoint)
        {
            LocalPoint = localPoint;
        }

        public void Listen()
        {
            _tcpSocket.Bind(LocalPoint);
            _tcpSocket.Listen(1000);
            _tcpSocket.BeginAccept(AcceptClientCallBack, _tcpSocket);
            IsListening = true;
        }

        public void Stop()
        {
            IsListening = false;
            foreach (var state in ClientList)
            {
                state.ClientSocket.Close();
            }
            ClientList.Clear();
            _tcpSocket.Close();
            OnlineChangeEvent?.Invoke(ClientList.Count, new IPEndPoint(IPAddress.Any, 0));
        }

        private void AcceptClientCallBack(IAsyncResult ar)
        {
            var server = ar.AsyncState as Socket;
            if (IsListening && server != null)
            {
                try
                {
                    var client = server.EndAccept(ar);
                    var clientState = new SocketState()
                    {
                        ClientSocket = client,
                        RemotePoint = client.RemoteEndPoint,
                    };
                    var tem = ClientList.FirstOrDefault(x => x.RemotePoint.Equals(clientState.RemotePoint));
                    if (tem != null)
                    {
                        tem.ClientSocket.Close();
                        ClientList.Remove(tem);
                    }
                    ClientList.Add(clientState);
                    BeginReveive(client);
                    OnlineChangeEvent?.Invoke(ClientList.Count, client.RemoteEndPoint);
                }
                catch (Exception error)
                {
                    ErrorEvent?.Invoke(error.Message, null);
                }
                finally
                {
                    server.BeginAccept(AcceptClientCallBack, server);
                }
            }
        }

        private void BeginReveive(Socket client)
        {
            if (client.Connected)
            {
                var state = new SocketState()
                {
                    ClientSocket = client,
                    RemotePoint = client.RemoteEndPoint,
                };
                client.BeginReceiveFrom(
                    state.Buffer,
                    0,
                    state.Buffer.Length,
                    SocketFlags.None,
                    ref state.RemotePoint,
                    ReceiveCallback,
                    state);
            }
        }

        private void ReceiveCallback(IAsyncResult ar)
        {
            var state = ar.AsyncState as SocketState;
            try
            {
                if (state != null && state.ClientSocket.Connected)
                {
                    state.DataLen = state.ClientSocket.EndReceiveFrom(ar, ref state.RemotePoint);
                    if (state.DataLen == 0)
                    {
                        state.ClientSocket.Close();
                        var tem = ClientList.FirstOrDefault(x => x.RemotePoint.Equals(state.RemotePoint));
                        ClientList.Remove(tem);
                        OnlineChangeEvent?.Invoke(ClientList.Count, state.RemotePoint);
                    }
                    else
                    {
                        byte[] receivedData = new byte[state.DataLen];
                        Array.Copy(state.Buffer, 0, receivedData, 0, state.DataLen);
                        state.Buffer = receivedData;
                        ReceivedDataEvent?.Invoke(state);
                    }
                }
            }
            catch (Exception error)
            {
                ErrorEvent?.Invoke(error.Message, state.RemotePoint);
                state.ClientSocket.Close();
                var tem = ClientList.FirstOrDefault(x => x.RemotePoint.Equals(state.RemotePoint));
                ClientList.Remove(tem);
                OnlineChangeEvent?.Invoke(ClientList.Count, state.RemotePoint);
            }
            finally
            {
                if (state != null) BeginReveive(state.ClientSocket);
            }
        }

        public void SendData(byte[] data, Socket client)
        {
            if (client.Connected)
            {
                var state = new SocketState()
                {
                    ClientSocket = client,
                    RemotePoint = client.RemoteEndPoint,
                    Buffer = data,
                    DataLen = data.Length,
                };
                client.BeginSendTo(data, 0, data.Length, SocketFlags.None, state.RemotePoint, SendCallback, state);
            }
        }

        private void SendCallback(IAsyncResult ar)
        {
            var state = ar.AsyncState as SocketState;
            try
            {
                if (state != null && state.ClientSocket.Connected)
                {
                    state.ClientSocket.EndSendTo(ar);
                }
            }
            catch (Exception error)
            {
                ErrorEvent?.Invoke(error.Message, state.RemotePoint);
            }
        }

        public event ReceiveDataHandler ReceivedDataEvent;

        public event OnlineChangeHandler OnlineChangeEvent;

        public event ErrorHandler ErrorEvent;
    }

    public class SocketState
    {
        public byte[] Buffer = new byte[1024*24];
        public Socket ClientSocket;
        public int DataLen;
        public EndPoint RemotePoint;
    }