Display_D_HP/TeamAAS-VM/Core/BgCommunicate.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeamAAS_VP.Enums;
using TeamAAS_VP.Models;
using TouchSocket.Core;
using TouchSocket.Sockets;

namespace TeamAAS_VP.Core
{
    public class BgCommunicate
    {
        private IWaitingClient<ITcpSessionClient, IReceiverResult> WaitClientServer;
        public TcpService TcpService { get; private set; }

        BgTcpIP Config;

        public event Action<ITcpSessionClient, ConnectedEventArgs> ConnectedEvent;
        public event Action<ITcpSessionClient, ClosedEventArgs> DisconnectedEvent;
        public event Action<ITcpSessionClient, string> ReceivedEvent;
        public event Action<ITcpSessionClient, string> SendEvent;

        public int Port { get => Config.Port; }

        public Terminator Terminator { get => Config.Terminator; }

        public DataEncoding DataEncoding { get => Config.DataEncoding; }

        public int ClientCount { get => TcpService.Count; }

        public BgCommunicate(BgTcpIP _Config) 
        {
            Config= _Config;
            TcpService = new TcpService();

            var config = new TouchSocketConfig();
            config.SetListenIPHosts(new IPHost[] { new IPHost(Config.Port) }); //同时监听两个地址
                                                                                                                       ////设置结束符
            if (Config.Terminator == Terminator.None)
            {
                config.SetTcpDataHandlingAdapter(() => { return new NormalDataHandlingAdapter(); });       ////亦或者省略\r\n，但此时调用方不能高速调用，会粘包
            }
            else if (Config.Terminator == Terminator.CR)
            {
                config.SetTcpDataHandlingAdapter(() => { return new TerminatorPackageAdapter("\r"); });       //命令行中使用\r结尾 
            }
            else if (Config.Terminator == Terminator.LF)
            {
                config.SetTcpDataHandlingAdapter(() => { return new TerminatorPackageAdapter("\n"); });       //命令行中使用\n结尾 
            }
            else if (Config.Terminator == Terminator.CRLF)
            {
                config.SetTcpDataHandlingAdapter(() => { return new TerminatorPackageAdapter("\r\n"); });       //命令行中使用\r\n结尾 
            }
            //载入配置
            TcpService.Setup(config);

            /////有客户端成功连接
            TcpService.Connected = ConnectedVoid;
            //有客户端断开连接
            TcpService.Closed = DisconnectedVoid;
            //从客户端收到信息
            TcpService.Received = ReceivedVoid;
        }

        /// <summary>
        /// 启动监听
        /// </summary>
        public void StartListening()
        {
            TcpService.Start();
        }

        /// <summary>
        /// 停止监听
        /// </summary>
        public void StopListening() 
        { 
            TcpService.Stop(); 
        }

        public void Dispose()
        {
            TcpService.Stop();
            TcpService.Dispose();
        }

        #region 事件接收
        /// <summary>
        /// 有客户端成功连接
        /// </summary>
        /// <param name="client"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Task ConnectedVoid(ITcpSessionClient client, ConnectedEventArgs e)
        {
            //调用CreateWaitingClient获取到IWaitingClient的对象。
            WaitClientServer = client.CreateWaitingClient(new WaitingOptions()
            {
                FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
                {
                    return true;

                    //if (response.Data.Length == 1)
                    //{
                    //    return true;
                    //}
                    //return false;
                }
            });
            ConnectedEvent?.Invoke(client, e);
            return EasyTask.CompletedTask;
        }
        /// <summary>
        /// 有客户端断开连接
        /// </summary>
        /// <param name="client"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Task DisconnectedVoid(ITcpSessionClient client, ClosedEventArgs e)
        {
            DisconnectedEvent?.Invoke(client, e);
            if (WaitClientServer != null)
            {
                if (WaitClientServer.Client.Id == client.Id)
                {
                    if (TcpService.Count > 0)
                    {
                        WaitClientServer = ((ITcpSessionClient)(TcpService.Clients.First())).CreateWaitingClient(new WaitingOptions()
                        {
                            FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
                            {
                                return true;

                                //if (response.Data.Length == 1)
                                //{
                                //    return true;
                                //}
                                //return false;
                            }
                        });
                    }
                }
            }
            return EasyTask.CompletedTask;
        }
        /// <summary>
        /// 从客户端收到信息
        /// </summary>
        /// <param name="client"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Task ReceivedVoid(ITcpSessionClient client, ReceivedDataEventArgs e)
        {
            Encoding encoding = GetEncoding();
            ReceivedEvent?.Invoke(client, e.ByteBlock.Span.ToString(encoding));
            //调用CreateWaitingClient获取到IWaitingClient的对象。
            WaitClientServer = client.CreateWaitingClient(new WaitingOptions()
            {
                FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
                {
                    return true;

                    //if (response.Data.Length == 1)
                    //{
                    //    return true;
                    //}
                    //return false;
                }
            });
            return EasyTask.CompletedTask;
        }
        #endregion

        #region 发送数据
        /// <summary>
        /// 发送信息给特定ID的客户端
        /// </summary>
        /// <param name="ID"></param>
        /// <param name="msg"></param>
        public void Send(string ID, string mes)
        {
            Encoding encoding = GetEncoding();
            var client = TcpService.Clients.FirstOrDefault(cl => cl.Id == ID);
            if (client!=null)
            {
                client.Send(encoding.GetBytes(mes));
                SendEvent?.Invoke(client,mes);
            }
        }

        /// <summary>
        /// 发送信息给特定ID的客户端
        /// </summary>
        /// <param name="ID"></param>
        /// <param name="mes"></param>
        public async Task SendAsync(string ID, string mes)
        {
            Encoding encoding = GetEncoding();
            var client = TcpService.Clients.FirstOrDefault(cl => cl.Id == ID);
            if (client != null)
            {
                await client.SendAsync(encoding.GetBytes(mes));
                SendEvent?.Invoke(client, mes);
            }
        }

        /// <summary>
        /// 发送信息给在线的所有客户端
        /// </summary>
        /// <param name="ID"></param>
        /// <param name="msg"></param>
        public void Send(string mes)
        {
            Encoding encoding = GetEncoding();
            foreach (var client in TcpService.Clients)
            {
                client.Send(encoding.GetBytes(mes));
                SendEvent?.Invoke(client, mes);
            }
        }

        /// <summary>
        /// 发送信息给在线的所有客户端
        /// </summary>
        /// <param name="mes"></param>
        public async Task SendAsync(string mes)
        {
            Encoding encoding = GetEncoding();
            foreach (var client in TcpService.Clients)
            {
                await client.SendAsync(encoding.GetBytes(mes));
                SendEvent?.Invoke(client, mes);
            }
        }

        /// <summary>
        /// 发送信息给客户端
        /// </summary>
        /// <param name="client">客户端</param>
        /// <param name="mes"></param>
        public void Send(ITcpSessionClient client, string mes)
        {
            Encoding encoding = GetEncoding();
            client.Send(encoding.GetBytes(mes));
            SendEvent?.Invoke(client, mes);
        }

        /// <summary>
        /// 发送信息给客户端
        /// </summary>
        /// <param name="client"></param>
        /// <param name="mes"></param>
        public async Task SendAsync(ITcpSessionClient client, string mes)
        {
            Encoding encoding = GetEncoding();
            await client.SendAsync(encoding.GetBytes(mes));
            SendEvent?.Invoke(client, mes);
        }

        /// <summary>
        /// 发送并接收数据(最后一次活动的客户端)
        /// </summary>
        /// <param name="mes"></param>
        /// <param name="millisecondsTimeout"></param>
        /// <returns></returns>
        public string SendThenReturn(string mes, int millisecondsTimeout = 5000)
        {
            Encoding encoding = GetEncoding();
            SendEvent?.Invoke(WaitClientServer.Client, mes);
            var returnData= WaitClientServer.SendThenReturn(encoding.GetBytes(mes), millisecondsTimeout);
            ReceivedEvent?.Invoke(WaitClientServer.Client, encoding.GetString(returnData));
            return encoding.GetString(returnData);
        }

        /// <summary>
        /// 发送并接收数据(最后一次活动的客户端)
        /// </summary>
        /// <param name="mes"></param>
        /// <param name="millisecondsTimeout"></param>
        /// <returns></returns>
        public async Task<string> SendThenReturnAsync(string mes, int millisecondsTimeout = 5000)
        {
            Encoding encoding = GetEncoding();
            SendEvent?.Invoke(WaitClientServer.Client, mes);
            var returnData = await WaitClientServer.SendThenReturnAsync(encoding.GetBytes(mes), millisecondsTimeout);
            ReceivedEvent?.Invoke(WaitClientServer.Client, encoding.GetString(returnData));
            return encoding.GetString(returnData);
        }

        /// <summary>
        /// 发送并接收数据
        /// </summary>
        /// <param name="client"></param>
        /// <param name="mes"></param>
        /// <param name="millisecondsTimeout"></param>
        /// <returns></returns>
        public string SendThenReturn(ITcpSessionClient client,string mes, int millisecondsTimeout = 5000)
        {
            WaitClientServer = client.CreateWaitingClient(new WaitingOptions()
            {
                FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
                {
                    return true;

                    //if (response.Data.Length == 1)
                    //{
                    //    return true;
                    //}
                    //return false;
                }
            });
            Encoding encoding = GetEncoding();
            SendEvent?.Invoke(WaitClientServer.Client, mes);
            var returnData = WaitClientServer.SendThenReturn(encoding.GetBytes(mes), millisecondsTimeout);
            ReceivedEvent?.Invoke(WaitClientServer.Client, encoding.GetString(returnData));
            return encoding.GetString(returnData);
        }

        /// <summary>
        /// 发送并接收数据
        /// </summary>
        /// <param name="client"></param>
        /// <param name="mes"></param>
        /// <param name="millisecondsTimeout"></param>
        /// <returns></returns>
        public async Task<string> SendThenReturnAsync(ITcpSessionClient client,string mes, int millisecondsTimeout = 5000)
        {
            WaitClientServer = client.CreateWaitingClient(new WaitingOptions()
            {
                FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
                {
                    return true;

                    //if (response.Data.Length == 1)
                    //{
                    //    return true;
                    //}
                    //return false;
                }
            });
            Encoding encoding = GetEncoding();
            SendEvent?.Invoke(WaitClientServer.Client, mes);
            var returnData = await WaitClientServer.SendThenReturnAsync(encoding.GetBytes(mes), millisecondsTimeout);
            ReceivedEvent?.Invoke(WaitClientServer.Client, encoding.GetString(returnData));
            return encoding.GetString(returnData);
        }
        #endregion

        #region 编码
        /// <summary>
        /// 获取编码
        /// </summary>
        /// <param name="dataEncoding"></param>
        /// <returns></returns>
        public Encoding GetEncoding()
        {
            DataEncoding dataEncoding = this.DataEncoding;
            Encoding encoding;
            if (dataEncoding == DataEncoding.Default)
            {
                encoding = Encoding.Default;
            }
            else if (dataEncoding == DataEncoding.ASCII)
            {
                encoding = Encoding.ASCII;
            }
            else if (dataEncoding == DataEncoding.UTF7)
            {
                encoding = Encoding.UTF7;
            }
            else if (dataEncoding == DataEncoding.UTF8)
            {
                encoding = Encoding.UTF8;
            }
            else if (dataEncoding == DataEncoding.UTF32)
            {
                encoding = Encoding.UTF32;
            }
            else if (dataEncoding == DataEncoding.Unicode)
            {
                encoding = Encoding.Unicode;
            }
            else if (dataEncoding == DataEncoding.BigEndianUnicode)
            {
                encoding = Encoding.BigEndianUnicode;
            }
            else if (dataEncoding == DataEncoding.GB2312)
            {

                encoding = Encoding.GetEncoding("gb2312");
            }
            else
            {
                encoding = Encoding.Default;
            }
            return encoding;
        }
        #endregion
    }
}