Fork/Azylee.Utils/Azylee.YeahWeb/SocketUtils/TcpUtils/TcppClient.cs

using Azylee.Core.ThreadUtils.SleepUtils;
using Azylee.Core.WindowsUtils.ConsoleUtils;
using Azylee.Jsons;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace Azylee.YeahWeb.SocketUtils.TcpUtils
{
    public class TcppClient
    {
        const int ReceiveBufferSize = 1024;
        private string _IP = "";
        private int _Port = 52801;
        private TcpClient Client = null;
        private NetworkStream networkStream = null;

        Action OnConnectAction = null;
        Action OnDisconnectAction = null;
        Action<TcpDataModel> OnReceiveAction = null;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="ip"></param>
        /// <param name="port"></param>
        /// <param name="onConnect">连接动作</param>
        /// <param name="onDisconnect">断开动作</param>
        /// <param name="onReceive">接收消息</param>
        public TcppClient(string ip, int port, Action onConnect, Action onDisconnect, Action<TcpDataModel> onReceive)
        {
            this._IP = ip;
            this._Port = port;

            OnConnectAction = onConnect;
            OnDisconnectAction = onDisconnect;
            OnReceiveAction = onReceive;
        }

        #region 连接和关闭连接
        /// <summary>
        /// 连接到TcpServer（重连）
        /// </summary>
        public bool Connect()
        {
            try
            {
                if (this.Client == null || !this.Client.Connected)
                {
                    this.Client = new TcpClient();
                    //this.Read();
                    IAsyncResult ar = this.Client.BeginConnect(this._IP, this._Port, acceptCallback, this.Client);
                    bool isConnect = ar.AsyncWaitHandle.WaitOne(1000);
                    if (isConnect) return true;
                }
            }
            catch { }
            return false;
        }
        /// <summary>
        /// 关闭连接
        /// </summary>
        public void Disconnect()
        {
            networkStream?.Close();
            Client?.Close();
        }
        #endregion

        #region 连接后的读写操作
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="model">数据模型</param>
        public bool Write(TcpDataModel model)
        {
            bool flag = false;
            if (this.Client != null && this.Client.Connected)
            {
                flag = TcpStreamHelper.Write(Client, model);
            }
            return flag;
        }
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="type">类型</param>
        /// <param name="data">数据</param>
        public bool Write(int type, byte[] data)
        {
            return Write(new TcpDataModel() { Type = type, Data = data });
        }
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="type">类型</param>
        /// <param name="s">字符串</param>
        public bool Write(int type, string s)
        {
            return Write(new TcpDataModel() { Type = type, Data = Json.Object2Byte(s) });
        }
        /// <summary>
        /// 接受数据
        /// </summary>
        private void acceptCallback(IAsyncResult state)
        {
            try
            {
                this.Client = (TcpClient)state.AsyncState;
                this.Client.EndConnect(state);

                // c# 系统检测到在一个调用中尝试使用指针参数时的无效指针地址 怎么解决
                // 用管理身份运行cmd，执行 netsh winsock reset 重启问题解决
                //string host = this.Client.Client.RemoteEndPoint.ToString();
                ConnectTask(Client);
            }
            catch (Exception ex) { }
        }
        private void ConnectTask(TcpClient client)
        {
            Task.Factory.StartNew(() =>
            {
                OnConnectAction?.Invoke();//委托：已连接
                while (client.Connected)
                {
                    try
                    {
                        TcpDataModel model = TcpStreamHelper.Read(client);
                        if (model != null)
                        {
                            if (model.Type == int.MaxValue)
                            {
                                //返回心跳
                                Write(new TcpDataModel() { Type = int.MaxValue });
                            }
                            else
                            {
                                OnReceiveAction?.Invoke(model);//委托：接收消息
                            }
                        }
                    }
                    catch { }
                    //Sleep.S(1);
                }
                client.Close();
                OnDisconnectAction?.Invoke();//委托：断开连接
            });
            //lstn.BeginAcceptTcpClient(new AsyncCallback(acceptCallback), lstn);
        }
        #endregion
    }
}