JiLinApp/JiLinApp.Docking/VibrateAlarm/Service/AsyncTcpServer.cs

using System.Collections.Concurrent;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Text;

namespace JiLinApp.Docking.VibrateAlarm;

public class AsyncTcpServer : IDisposable
{
    #region Fields

    private TcpListener _listener;
    private ConcurrentDictionary<string, TcpClientState> _clients;
    private bool _disposed = false;

    #endregion Fields

    #region Ctors

    private byte[] inOptionValues;

    /// <summary>
    /// 异步TCP服务器
    /// </summary>
    /// <param name="listenPort">监听的端口</param>
    public AsyncTcpServer(int listenPort)
        : this(IPAddress.Any, listenPort)
    {
        uint dummy = 0;
        inOptionValues = new byte[Marshal.SizeOf(dummy) * 3];
        BitConverter.GetBytes((uint)1).CopyTo(inOptionValues, 0);
        BitConverter.GetBytes((uint)1000).CopyTo(inOptionValues, Marshal.SizeOf(dummy));
        BitConverter.GetBytes((uint)1000).CopyTo(inOptionValues, Marshal.SizeOf(dummy) * 2);
    }

    /// <summary>
    /// 异步TCP服务器
    /// </summary>
    /// <param name="localEP">监听的终结点</param>
    public AsyncTcpServer(IPEndPoint localEP)
        : this(localEP.Address, localEP.Port)
    {
        uint dummy = 0;
        inOptionValues = new byte[Marshal.SizeOf(dummy) * 3];
        BitConverter.GetBytes((uint)1).CopyTo(inOptionValues, 0);
        BitConverter.GetBytes((uint)1000).CopyTo(inOptionValues, Marshal.SizeOf(dummy));
        BitConverter.GetBytes((uint)1000).CopyTo(inOptionValues, Marshal.SizeOf(dummy) * 2);
    }

    /// <summary>
    /// 异步TCP服务器
    /// </summary>
    /// <param name="localIPAddress">监听的IP地址</param>
    /// <param name="listenPort">监听的端口</param>
    public AsyncTcpServer(IPAddress localIPAddress, int listenPort)
    {
        uint dummy = 0;
        inOptionValues = new byte[Marshal.SizeOf(dummy) * 3];
        BitConverter.GetBytes((uint)1).CopyTo(inOptionValues, 0);
        BitConverter.GetBytes((uint)1000).CopyTo(inOptionValues, Marshal.SizeOf(dummy));
        BitConverter.GetBytes((uint)1000).CopyTo(inOptionValues, Marshal.SizeOf(dummy) * 2);
        Address = localIPAddress;
        Port = listenPort;
        Encoding = Encoding.Default;

        _clients = new ConcurrentDictionary<string, TcpClientState>();

        _listener = new TcpListener(Address, Port);
        _listener.AllowNatTraversal(true);
    }

    #endregion Ctors

    #region Properties

    /// <summary>
    /// 服务器是否正在运行
    /// </summary>
    public bool IsRunning { get; private set; }

    /// <summary>
    /// 监听的IP地址
    /// </summary>
    public IPAddress Address { get; private set; }

    /// <summary>
    /// 监听的端口
    /// </summary>
    public int Port { get; private set; }

    /// <summary>
    /// 通信使用的编码
    /// </summary>
    public Encoding Encoding { get; set; }

    #endregion Properties

    #region Server

    /// <summary>
    /// 启动服务器
    /// </summary>
    /// <returns>异步TCP服务器</returns>
    public AsyncTcpServer Start()
    {
        return Start(30);
    }

    /// <summary>
    /// 启动服务器
    /// </summary>
    /// <param name="backlog">服务器所允许的挂起连接序列的最大长度</param>
    /// <returns>异步TCP服务器</returns>
    public AsyncTcpServer Start(int backlog)
    {
        if (IsRunning) return this;

        IsRunning = true;
        _listener.Start(backlog);
        ContinueAcceptTcpClient(_listener);

        return this;
    }

    /// <summary>
    /// 停止服务器
    /// </summary>
    /// <returns>异步TCP服务器</returns>
    public AsyncTcpServer Stop()
    {
        if (!IsRunning) return this;

        try
        {
            _listener.Stop();

            foreach (var client in _clients.Values)
            {
                client.TcpClient.Client.Disconnect(false);
            }
            _clients.Clear();
        }
        catch (ObjectDisposedException ex)
        {
            Console.WriteLine("对象注销错误：" + ex.Message);
        }
        catch (SocketException ex)
        {
            Console.WriteLine("socket错误：" + ex.Message);
        }
        IsRunning = false;

        return this;
    }

    private void ContinueAcceptTcpClient(TcpListener tcpListener)
    {
        try
        {
            tcpListener.BeginAcceptTcpClient(new AsyncCallback(HandleTcpClientAccepted), tcpListener);
        }
        catch (ObjectDisposedException ex)
        {
            Console.WriteLine("对象注销错误：" + ex.Message);
        }
        catch (SocketException ex)
        {
            Console.WriteLine("socket错误：" + ex.Message);
        }
    }

    #endregion Server

    #region Receive

    private void HandleTcpClientAccepted(IAsyncResult ar)
    {
        if (!IsRunning) return;

        TcpListener tcpListener;
        TcpClient tcpClient;
        try
        {
            tcpListener = (TcpListener)ar.AsyncState;
            tcpClient = tcpListener.EndAcceptTcpClient(ar);
            tcpClient.Client.IOControl(IOControlCode.KeepAliveValues, inOptionValues, null);
        }
        catch (ObjectDisposedException ex)
        {
            Console.WriteLine("对象注销错误：" + ex.Message);
            return;
        }
        if (!tcpClient.Connected) return;

        byte[] buffer = new byte[tcpClient.ReceiveBufferSize];
        TcpClientState internalClient = new TcpClientState(tcpClient, buffer);

        // add client connection to cache
        string tcpClientKey = internalClient.TcpClient.Client.RemoteEndPoint.ToString();
        _clients.AddOrUpdate(tcpClientKey, internalClient, (n, o) => { return internalClient; });
        RaiseClientConnected(tcpClient);

        // begin to read data
        NetworkStream networkStream = internalClient.NetworkStream;
        ContinueReadBuffer(internalClient, networkStream);

        // keep listening to accept next connection
        ContinueAcceptTcpClient(tcpListener);
    }

    private void HandleDatagramReceived(IAsyncResult ar)
    {
        if (!IsRunning) return;

        try
        {
            TcpClientState internalClient = (TcpClientState)ar.AsyncState;
            if (!internalClient.TcpClient.Connected) return;

            NetworkStream networkStream = internalClient.NetworkStream;

            int numberOfReadBytes = 0;
            try
            {
                // if the remote host has shutdown its connection,
                // read will immediately return with zero bytes.
                numberOfReadBytes = networkStream.EndRead(ar);
            }
            catch (Exception ex)
            {
                Console.WriteLine("错误：" + ex.Message);
                numberOfReadBytes = 0;
            }

            if (numberOfReadBytes == 0)
            {
                // connection has been closed
                TcpClientState internalClientToBeThrowAway;
                string tcpClientKey = internalClient.TcpClient.Client.RemoteEndPoint.ToString();
                _clients.TryRemove(tcpClientKey, out internalClientToBeThrowAway);
                RaiseClientDisconnected(internalClient.TcpClient);
                return;
            }

            // received byte and trigger event notification
            byte[] receivedBytes = new byte[numberOfReadBytes];
            Buffer.BlockCopy(internalClient.Buffer, 0, receivedBytes, 0, numberOfReadBytes);
            RaiseDatagramReceived(internalClient, receivedBytes);

            // continue listening for tcp datagram packets
            ContinueReadBuffer(internalClient, networkStream);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine("错误：" + ex.Message);
        }
    }

    private void ContinueReadBuffer(TcpClientState internalClient, NetworkStream networkStream)
    {
        try
        {
            networkStream.BeginRead(internalClient.Buffer, 0, internalClient.Buffer.Length, HandleDatagramReceived, internalClient);
        }
        catch (ObjectDisposedException ex)
        {
            Console.WriteLine("对象注销错误：" + ex.Message);
        }
    }

    #endregion Receive

    #region Events

    /// <summary>
    /// 接收到数据报文事件
    /// </summary>
    public event EventHandler<TcpDatagramReceivedEventArgs<byte[]>> DatagramReceived;

    private void RaiseDatagramReceived(TcpClientState sender, byte[] datagram)
    {
        if (DatagramReceived != null)
        {
            DatagramReceived(this, new TcpDatagramReceivedEventArgs<byte[]>(sender, datagram));
        }
    }

    /// <summary>
    /// 与客户端的连接已建立事件
    /// </summary>
    public event EventHandler<TcpClientConnectedEventArgs> ClientConnected;

    /// <summary>
    /// 与客户端的连接已断开事件
    /// </summary>
    public event EventHandler<TcpClientDisconnectedEventArgs> ClientDisconnected;

    private void RaiseClientConnected(TcpClient tcpClient)
    {
        if (ClientConnected != null)
        {
            ClientConnected(this, new TcpClientConnectedEventArgs(tcpClient));
        }
    }

    private void RaiseClientDisconnected(TcpClient tcpClient)
    {
        if (ClientDisconnected != null)
        {
            ClientDisconnected(this, new TcpClientDisconnectedEventArgs(tcpClient));
        }
    }

    #endregion Events

    #region Send

    private void GuardRunning()
    {
        if (!IsRunning)
            throw new InvalidProgramException("This TCP server has not been started yet.");
    }

    /// <summary>
    /// 发送报文至指定的客户端
    /// </summary>
    /// <param name="tcpClient">客户端</param>
    /// <param name="datagram">报文</param>
    public void Send(TcpClient tcpClient, byte[] datagram)
    {
        GuardRunning();

        if (tcpClient == null)
            throw new ArgumentNullException("tcpClient");

        if (datagram == null)
            throw new ArgumentNullException("datagram");

        try
        {
            NetworkStream stream = tcpClient.GetStream();
            if (stream.CanWrite)
            {
                stream.BeginWrite(datagram, 0, datagram.Length, HandleDatagramWritten, tcpClient);
            }
        }
        catch (ObjectDisposedException ex)
        {
            Console.WriteLine("对象注销错误：" + ex.Message);
        }
    }

    /// <summary>
    /// 发送报文至指定的客户端
    /// </summary>
    /// <param name="tcpClient">客户端</param>
    /// <param name="datagram">报文</param>
    public void Send(TcpClient tcpClient, string datagram)
    {
        Send(tcpClient, Encoding.GetBytes(datagram));
    }

    /// <summary>
    /// 发送报文至所有客户端
    /// </summary>
    /// <param name="datagram">报文</param>
    public void SendToAll(byte[] datagram)
    {
        GuardRunning();

        foreach (var client in _clients.Values)
        {
            Send(client.TcpClient, datagram);
        }
    }

    public ICollection<TcpClientState> GetAllClient()
    {
        return _clients.Values;
    }

    /// <summary>
    /// 发送报文至所有客户端
    /// </summary>
    /// <param name="datagram">报文</param>
    public void SendToAll(string datagram)
    {
        GuardRunning();

        SendToAll(Encoding.GetBytes(datagram));
    }

    private void HandleDatagramWritten(IAsyncResult ar)
    {
        try
        {
            ((TcpClient)ar.AsyncState).GetStream().EndWrite(ar);
        }
        catch (ObjectDisposedException ex)
        {
            Console.WriteLine("对象注销错误：" + ex.Message);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine("错误：" + ex.Message);
        }
        catch (IOException ex)
        {
            Console.WriteLine("错误：" + ex.Message);
        }
    }

    /// <summary>
    /// 发送报文至指定的客户端
    /// </summary>
    /// <param name="tcpClient">客户端</param>
    /// <param name="datagram">报文</param>
    public void SyncSend(TcpClient tcpClient, byte[] datagram)
    {
        GuardRunning();

        if (tcpClient == null)
            throw new ArgumentNullException("tcpClient");

        if (datagram == null)
            throw new ArgumentNullException("datagram");

        try
        {
            NetworkStream stream = tcpClient.GetStream();
            if (stream.CanWrite)
            {
                stream.Write(datagram, 0, datagram.Length);
            }
        }
        catch (ObjectDisposedException ex)
        {
            Console.WriteLine("对象注销错误：" + ex.Message);
        }
    }

    /// <summary>
    /// 发送报文至指定的客户端
    /// </summary>
    /// <param name="tcpClient">客户端</param>
    /// <param name="datagram">报文</param>
    public void SyncSend(TcpClient tcpClient, string datagram)
    {
        SyncSend(tcpClient, Encoding.GetBytes(datagram));
    }

    /// <summary>
    /// 发送报文至所有客户端
    /// </summary>
    /// <param name="datagram">报文</param>
    public void SyncSendToAll(byte[] datagram)
    {
        GuardRunning();

        foreach (var client in _clients.Values)
        {
            SyncSend(client.TcpClient, datagram);
        }
    }

    /// <summary>
    /// 发送报文至所有客户端
    /// </summary>
    /// <param name="datagram">报文</param>
    public void SyncSendToAll(string datagram)
    {
        GuardRunning();

        SyncSendToAll(Encoding.GetBytes(datagram));
    }

    #endregion Send

    #region IDisposable Members

    /// <summary>
    /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
    /// </summary>
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    /// <summary>
    /// Releases unmanaged and - optionally - managed resources
    /// </summary>
    /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources;
    /// <c>false</c> to release only unmanaged resources.</param>
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                try
                {
                    Stop();

                    if (_listener != null)
                    {
                        _listener = null;
                    }
                }
                catch (SocketException ex)
                {
                    Console.WriteLine("socket错误：" + ex.Message);
                }
            }

            _disposed = true;
        }
    }

    #endregion IDisposable Members
}