支持.NetStandard2.0

Lib/NetLib_Standard2/NoSugarNet.DataHelper.deps.json

@@ -0,0 +1,47 @@
+{
+  "runtimeTarget": {
+    "name": ".NETStandard,Version=v2.0/",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETStandard,Version=v2.0": {},
+    ".NETStandard,Version=v2.0/": {
+      "NoSugarNet.DataHelper/1.0.0": {
+        "dependencies": {
+          "NETStandard.Library": "2.0.3"
+        },
+        "runtime": {
+          "NoSugarNet.DataHelper.dll": {}
+        }
+      },
+      "Microsoft.NETCore.Platforms/1.1.0": {},
+      "NETStandard.Library/2.0.3": {
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "1.1.0"
+        }
+      }
+    }
+  },
+  "libraries": {
+    "NoSugarNet.DataHelper/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Microsoft.NETCore.Platforms/1.1.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A==",
+      "path": "microsoft.netcore.platforms/1.1.0",
+      "hashPath": "microsoft.netcore.platforms.1.1.0.nupkg.sha512"
+    },
+    "NETStandard.Library/2.0.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==",
+      "path": "netstandard.library/2.0.3",
+      "hashPath": "netstandard.library.2.0.3.nupkg.sha512"
+    }
+  }
+}

NoSugarNet.ClientCore.Standard2/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
+    </startup>
+</configuration>

NoSugarNet.ClientCore.Standard2/AppNoSugarNet.cs

@@ -0,0 +1,84 @@
+using NoSugarNet.ClientCoreNet.Standard2.Manager;
+using NoSugarNet.ClientCoreNet.Standard2.Network;
+using ServerCore.Manager;
+using static NoSugarNet.ClientCoreNet.Standard2.Manager.LogManager;
+
+namespace NoSugarNet.ClientCoreNet.Standard2
+{
+    public class AppNoSugarNet
+    {
+        public static string TokenStr;
+        public static long RID = -1;
+        public static string IP;
+        public static int Port;
+        public static LogManager log;
+        public static NetworkHelper networkHelper;
+        public static AppLogin login;
+        public static AppChat chat;
+        public static AppLocalClient local;
+        public static UserDataManager user;
+        public static System.Timers.Timer _SpeedCheckTimeTimer;//速度检测计时器
+        public static int TimerInterval = 1000;//计时器间隔
+        static NetStatus netStatus;
+
+        #region 委托和事件
+        public delegate void OnUpdateStatusHandler(NetStatus Status);
+        public static event OnUpdateStatusHandler OnUpdateStatus;
+        #endregion
+
+        public static void Init(OnLogHandler onLog = null)
+        {
+            log = new LogManager();
+            if(onLog != null)
+                LogManager.OnLog += onLog;
+            networkHelper = new NetworkHelper();
+            login = new AppLogin();
+            chat = new AppChat();
+            local = new AppLocalClient();
+            user = new UserDataManager();
+            netStatus = new NetStatus();
+            _SpeedCheckTimeTimer = new System.Timers.Timer();
+            _SpeedCheckTimeTimer.Interval = TimerInterval;
+            _SpeedCheckTimeTimer.Elapsed += Checktimer_Elapsed;
+            _SpeedCheckTimeTimer.AutoReset = true;
+        }
+
+        public static void Connect(string IP, int port)
+        {
+            if (networkHelper.Init(IP, port))
+                _SpeedCheckTimeTimer.Enabled = true;
+            else
+                _SpeedCheckTimeTimer.Enabled = false;
+        }
+
+        public static void Close()
+        {
+            local.StopAll();
+            networkHelper.CloseConntect();
+            AppNoSugarNet.log.Info("停止");
+            _SpeedCheckTimeTimer.Enabled = false;
+        }
+
+        static void Checktimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
+        {
+            local.GetCurrLenght(out long resultReciveAllLenght, out long resultSendAllLenght);
+            local.GetClientCount(out int ClientUserCount, out int TunnelCount);
+
+            NetStatus resutnetStatus = new NetStatus()
+            {
+                TunnelCount = TunnelCount,
+                ClientUserCount = ClientUserCount,
+                srcSendAllLenght = resultSendAllLenght,
+                srcReciveAllLenght = resultReciveAllLenght,
+                srcReciveSecSpeed = (resultReciveAllLenght - netStatus.srcReciveAllLenght) / (TimerInterval / 1000),
+                srcSendSecSpeed = (resultSendAllLenght - netStatus.srcSendAllLenght) / (TimerInterval / 1000),
+                tSendAllLenght = local.tSendAllLenght,
+                tReciveAllLenght = local.tReciveAllLenght,
+                tSendSecSpeed = (local.tSendAllLenght - netStatus.tSendAllLenght) / (TimerInterval / 1000),
+                tReciveSecSpeed = (local.tReciveAllLenght - netStatus.tReciveAllLenght) / (TimerInterval / 1000),
+            };
+            netStatus = resutnetStatus;
+            OnUpdateStatus?.Invoke(resutnetStatus);
+        }
+    }
+}

NoSugarNet.ClientCore.Standard2/Common/Helper.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace NoSugarNet.ClientCoreNet.Standard2.Common
+{
+    public static class Helper
+    {
+        public static long GetNowTimeStamp()
+        {
+            return GetTimeStamp(DateTime.Now);
+        }
+
+        /// <summary>
+        /// 获取时间戳
+        /// </summary>
+        /// <returns></returns>
+        public static long GetTimeStamp(DateTime dt)
+        {
+            TimeSpan ts = dt - new DateTime(1970, 1, 1, 0, 0, 0, 0);
+            return Convert.ToInt64(ts.TotalSeconds);
+        }
+    }
+}

NoSugarNet.ClientCore.Standard2/Common/ProtoBufHelper.cs

@@ -0,0 +1,21 @@
+using Google.Protobuf;
+using System;
+
+namespace NoSugarNet.ClientCoreNet.Standard2.Common
+{
+    public static class ProtoBufHelper
+    {
+        public static byte[] Serizlize(IMessage msg)
+        {
+            return msg.ToByteArray();
+        }
+        public static T DeSerizlize<T>(byte[] bytes)
+        {
+            var msgType = typeof(T);
+            object msg = Activator.CreateInstance(msgType);
+            ((IMessage)msg).MergeFrom(bytes);
+            return (T)msg;
+        }
+    }
+
+}

NoSugarNet.ClientCore.Standard2/Event/EEvent.cs

@@ -0,0 +1,8 @@
+namespace NoSugarNet.ClientCoreNet.Standard2.Event
+{
+    public enum EEvent
+    {
+        // 添加你自己需要的事件类型
+        OnChatMsg
+    }
+}

NoSugarNet.ClientCore.Standard2/Event/EventSystem.cs

@@ -0,0 +1,241 @@
+using System;
+using System.Collections.Generic;
+
+namespace NoSugarNet.ClientCoreNet.Standard2.Event
+{
+    public class EventData
+    {
+        private static long BaseUid = 0;
+        private static long GenUid()
+        {
+            return (++BaseUid);
+        }
+
+        /// <summary>
+        /// 唯一id
+        /// </summary>
+        public long uid { get; private set; }
+
+        /// <summary>
+        /// 回调
+        /// </summary>
+        public Delegate callback { get; private set; }
+
+        public EventData(Delegate d)
+        {
+            uid = GenUid();
+            callback = d;
+        }
+    }
+
+    public class EventSystem
+    {
+        private static EventSystem instance = new EventSystem();
+        public static EventSystem Instance { get { return instance; } }
+
+        private Dictionary<EEvent, List<Delegate>> eventDic = new Dictionary<EEvent, List<Delegate>>(128);
+
+        private EventSystem() { }
+
+
+        #region RegisterEvent
+        public void RegisterEvent(EEvent evt, Action callback)
+        {
+            InterRegisterEvent(evt, callback);
+        }
+
+        public void RegisterEvent<T1>(EEvent evt, Action<T1> callback)
+        {
+            InterRegisterEvent(evt, callback);
+        }
+
+        public void RegisterEvent<T1, T2>(EEvent evt, Action<T1, T2> callback)
+        {
+            InterRegisterEvent(evt, callback);
+        }
+
+        public void RegisterEvent<T1, T2, T3>(EEvent evt, Action<T1, T2, T3> callback)
+        {
+            InterRegisterEvent(evt, callback);
+        }
+
+        public void RegisterEvent<T1, T2, T3, T4>(EEvent evt, Action<T1, T2, T3, T4> callback)
+        {
+            InterRegisterEvent(evt, callback);
+        }
+
+        private void InterRegisterEvent(EEvent evt, Delegate callback)
+        {
+            if (eventDic.ContainsKey(evt))
+            {
+                if (eventDic[evt].IndexOf(callback) < 0)
+                {
+                    eventDic[evt].Add(callback);
+                }
+            }
+            else
+            {
+                eventDic.Add(evt, new List<Delegate>() { callback });
+            }
+        }
+        #endregion
+
+        #region UnregisterEvent
+
+        public void UnregisterEvent(EEvent evt, Action callback)
+        {
+            Delegate tempDelegate = callback;
+            InterUnregisterEvent(evt, tempDelegate);
+        }
+
+        public void UnregisterEvent<T1>(EEvent evt, Action<T1> callback)
+        {
+            Delegate tempDelegate = callback;
+            InterUnregisterEvent(evt, tempDelegate);
+        }
+
+        public void UnregisterEvent<T1, T2>(EEvent evt, Action<T1, T2> callback)
+        {
+            Delegate tempDelegate = callback;
+            InterUnregisterEvent(evt, tempDelegate);
+        }
+
+        public void UnregisterEvent<T1, T2, T3>(EEvent evt, Action<T1, T2, T3> callback)
+        {
+            Delegate tempDelegate = callback;
+            InterUnregisterEvent(evt, tempDelegate);
+        }
+
+        public void UnregisterEvent<T1, T2, T3, T4>(EEvent evt, Action<T1, T2, T3, T4> callback)
+        {
+            Delegate tempDelegate = callback;
+            InterUnregisterEvent(evt, tempDelegate);
+        }
+
+        private void InterUnregisterEvent(EEvent evt, Delegate callback)
+        {
+            if (eventDic.ContainsKey(evt))
+            {
+                eventDic[evt].Remove(callback);
+                if (eventDic[evt].Count == 0) eventDic.Remove(evt);
+            }
+        }
+        #endregion
+
+        #region PostEvent
+        public void PostEvent<T1, T2, T3, T4>(EEvent evt, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            List<Delegate> eventList = GetEventList(evt);
+            if (eventList != null)
+            {
+                foreach (Delegate callback in eventList)
+                {
+                    try
+                    {
+                        ((Action<T1, T2, T3, T4>)callback)(arg1, arg2, arg3, arg4);
+                    }
+                    catch (Exception e)
+                    {
+                        AppNoSugarNet.log.Error(e.Message);
+                    }
+                }
+            }
+        }
+
+        public void PostEvent<T1, T2, T3>(EEvent evt, T1 arg1, T2 arg2, T3 arg3)
+        {
+            List<Delegate> eventList = GetEventList(evt);
+            if (eventList != null)
+            {
+                foreach (Delegate callback in eventList)
+                {
+                    try
+                    {
+                        ((Action<T1, T2, T3>)callback)(arg1, arg2, arg3);
+                    }
+                    catch (Exception e)
+                    {
+                        AppNoSugarNet.log.Error(e.Message);
+                    }
+                }
+            }
+        }
+
+        public void PostEvent<T1, T2>(EEvent evt, T1 arg1, T2 arg2)
+        {
+            List<Delegate> eventList = GetEventList(evt);
+            if (eventList != null)
+            {
+                foreach (Delegate callback in eventList)
+                {
+                    try
+                    {
+                        ((Action<T1, T2>)callback)(arg1, arg2);
+                    }
+                    catch (Exception e)
+                    {
+                        AppNoSugarNet.log.Error(e.Message);
+                    }
+                }
+            }
+        }
+
+        public void PostEvent<T>(EEvent evt, T arg)
+        {
+            List<Delegate> eventList = GetEventList(evt);
+            if (eventList != null)
+            {
+                foreach (Delegate callback in eventList)
+                {
+                    try
+                    {
+                        ((Action<T>)callback)(arg);
+                    }
+                    catch (Exception e)
+                    {
+                        AppNoSugarNet.log.Error(e.Message + ", method name : " + callback.Method);
+                    }
+                }
+            }
+
+        }
+
+        public void PostEvent(EEvent evt)
+        {
+            List<Delegate> eventList = GetEventList(evt);
+            if (eventList != null)
+            {
+                foreach (Delegate callback in eventList)
+                {
+                    try
+                    {
+                        ((Action)callback)();
+                    }
+                    catch (Exception e)
+                    {
+                        AppNoSugarNet.log.Error(e.Message);
+                    }
+                }
+            }
+        }
+        #endregion
+
+        /// <summary>
+        /// 获取所有事件
+        /// </summary>
+        /// <param name="evt"></param>
+        /// <returns></returns>
+        private List<Delegate> GetEventList(EEvent evt)
+        {
+            if (eventDic.ContainsKey(evt))
+            {
+                List<Delegate> tempList = eventDic[evt];
+                if (null != tempList)
+                {
+                    return tempList;
+                }
+            }
+            return null;
+        }
+    }
+}

NoSugarNet.ClientCore.Standard2/Manager/AppChat.cs

@@ -0,0 +1,30 @@
+using AxibugProtobuf;
+using NoSugarNet.ClientCoreNet.Standard2.Common;
+using NoSugarNet.ClientCoreNet.Standard2.Event;
+using NoSugarNet.ClientCoreNet.Standard2.Network;
+
+namespace NoSugarNet.ClientCoreNet.Standard2.Manager
+{
+    public class AppChat
+    {
+        public AppChat()
+        {
+            NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdChatmsg, RecvChatMsg);
+        }
+
+        public void SendChatMsg(string ChatMsg)
+        {
+            Protobuf_ChatMsg msg = new Protobuf_ChatMsg()
+            {
+                ChatMsg = ChatMsg,
+            };
+            AppNoSugarNet.networkHelper.SendToServer((int)CommandID.CmdChatmsg, ProtoBufHelper.Serizlize(msg));
+        }
+
+        public void RecvChatMsg(byte[] reqData)
+        {
+            Protobuf_ChatMsg_RESP msg = ProtoBufHelper.DeSerizlize<Protobuf_ChatMsg_RESP>(reqData);
+            EventSystem.Instance.PostEvent(EEvent.OnChatMsg, msg.NickName, msg.ChatMsg);
+        }
+    }
+}

NoSugarNet.ClientCore.Standard2/Manager/AppLocalClient.cs

@@ -0,0 +1,337 @@
+using AxibugProtobuf;
+using Google.Protobuf;
+using NoSugarNet.ClientCoreNet.Standard2;
+using NoSugarNet.ClientCoreNet.Standard2.Common;
+using NoSugarNet.ClientCoreNet.Standard2.Network;
+using NoSugarNet.DataHelper;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+
+namespace ServerCore.Manager
+{
+    public class AppLocalClient
+    {
+        Dictionary<byte, Protobuf_Cfgs_Single> mDictTunnelID2Cfg = new Dictionary<byte, Protobuf_Cfgs_Single>();
+        Dictionary<byte, LocalListener> mDictTunnelID2Listeners = new Dictionary<byte, LocalListener>();
+        CompressAdapter mCompressAdapter;
+        E_CompressAdapter compressAdapterType;
+        public LocalMsgQueuePool _localMsgPool = new LocalMsgQueuePool(1000);
+
+        public long tReciveAllLenght { get; private set; }
+        public long tSendAllLenght { get; private set; }
+
+        public AppLocalClient()
+        {
+            //注册网络消息
+            NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdCfgs, Recive_CmdCfgs);
+            NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdTunnelS2CConnect, Recive_TunnelS2CConnect);
+            NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdTunnelS2CDisconnect, Recive_TunnelS2CDisconnect);
+            NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdTunnelS2CData, Recive_TunnelS2CData);
+        }
+
+        public void GetCurrLenght(out long resultReciveAllLenght, out long resultSendAllLenght)
+        {
+            resultReciveAllLenght = 0;
+            resultSendAllLenght = 0;
+            byte[] Keys = mDictTunnelID2Listeners.Keys.ToArray();
+            for (int i = 0; i < Keys.Length; i++)
+            {
+                //local和转发 收发相反
+                resultSendAllLenght += mDictTunnelID2Listeners[Keys[i]].mReciveAllLenght;
+                resultReciveAllLenght += mDictTunnelID2Listeners[Keys[i]].mSendAllLenght;
+            }
+        }
+
+
+        public void GetClientCount(out int ClientUserCount, out int TunnelCount)
+        {
+            TunnelCount = mDictTunnelID2Listeners.Count;
+            ClientUserCount = mDictTunnelID2Listeners.Count;
+        }
+
+        /// <summary>
+        /// 初始化连接，先获取到配置
+        /// </summary>
+        void InitListenerMode()
+        {
+            AppNoSugarNet.log.Info("初始化压缩适配器" + compressAdapterType);
+            //初始化压缩适配器，代表压缩类型
+            mCompressAdapter = new CompressAdapter(compressAdapterType);
+            foreach (var cfg in mDictTunnelID2Cfg)
+            {
+                LocalListener listener = new LocalListener(256, 1024, cfg.Key);
+                AppNoSugarNet.log.Info($"开始监听配置 Tunnel:{cfg.Key},Port:{cfg.Value.Port}");
+                listener.Init();
+                listener.Start(new IPEndPoint(IPAddress.Any.Address, (int)cfg.Value.Port));
+                //listener.Init((int)cfg.Value.Port);
+                AddLocalListener(listener);
+            }
+
+        }
+
+        #region 连接字典管理
+        /// <summary>
+        /// 追加监听者
+        /// </summary>
+        /// <param name="tunnelId"></param>
+        /// <param name="serverClient"></param>
+        void AddLocalListener(LocalListener _listener)
+        {
+            lock (mDictTunnelID2Listeners)
+            {
+                mDictTunnelID2Listeners[_listener.mTunnelID] = _listener;
+            }
+        }
+        /// <summary>
+        /// 删除监听
+        /// </summary>
+        /// <param name="tunnelId"></param>
+        /// <param name="serverClient"></param>
+        void RemoveLocalListener(LocalListener _listener)
+        {
+            lock (mDictTunnelID2Listeners)
+            {
+                if (mDictTunnelID2Listeners.ContainsKey(_listener.mTunnelID))
+                {
+                    mDictTunnelID2Listeners.Remove(_listener.mTunnelID);
+                }
+            }
+        }
+        bool GetLocalListener(byte tunnelId,out LocalListener _listener)
+        {
+            _listener = null;
+            if (!mDictTunnelID2Listeners.ContainsKey(tunnelId))
+                return false;
+
+            _listener = mDictTunnelID2Listeners[tunnelId];
+            return true;
+        }
+        public void StopAll()
+        {
+            lock (mDictTunnelID2Listeners) 
+            {
+                byte[] keys = mDictTunnelID2Listeners.Keys.ToArray();
+                for (int i = 0; i < keys.Length; i++) 
+                {
+                    LocalListener _listener = mDictTunnelID2Listeners[keys[i]];
+                    _listener.StopAll();
+                    //_listener.Stop();
+                    RemoveLocalListener(_listener);
+                }
+            }
+        }
+        #endregion
+
+        #region 解析服务端下行数据
+        public void Recive_CmdCfgs(byte[] reqData)
+        {
+            AppNoSugarNet.log.Debug("Recive_CmdCfgs");
+            Protobuf_Cfgs msg = ProtoBufHelper.DeSerizlize<Protobuf_Cfgs>(reqData);
+
+            for (int i = 0;i < msg.Cfgs.Count;i++) 
+            {
+                Protobuf_Cfgs_Single cfg = msg.Cfgs[i];
+                mDictTunnelID2Cfg[(byte)cfg.TunnelID] = cfg;
+            }
+            compressAdapterType = (E_CompressAdapter)msg.CompressAdapterType;
+            InitListenerMode();
+        }
+        public void Recive_TunnelS2CConnect(byte[] reqData)
+        {
+            AppNoSugarNet.log.Debug("Recive_TunnelS2CConnect");
+            Protobuf_S2C_Connect msg = ProtoBufHelper.DeSerizlize<Protobuf_S2C_Connect>(reqData);
+            if(msg.Connected == 1)
+                OnServerLocalConnect((byte)msg.TunnelID,(byte)msg.Idx);
+            else
+                OnServerLocalDisconnect((byte)msg.TunnelID, (byte)msg.Idx);
+        }
+        public void Recive_TunnelS2CDisconnect(byte[] reqData)
+        {
+            AppNoSugarNet.log.Debug("Recive_TunnelS2CDisconnect");
+            Protobuf_S2C_Disconnect msg = ProtoBufHelper.DeSerizlize<Protobuf_S2C_Disconnect>(reqData);
+            OnServerLocalDisconnect((byte)msg.TunnelID,(byte)msg.Idx);
+        }
+        public void Recive_TunnelS2CData(byte[] reqData)
+        {
+            //AppNoSugarNet.log.Debug("Recive_TunnelS2CData");
+            Protobuf_S2C_DATA msg = ProtoBufHelper.DeSerizlize<Protobuf_S2C_DATA>(reqData);
+            OnServerLocalDataCallBack((byte)msg.TunnelID,(byte)msg.Idx, msg.HunterNetCoreData.ToArray());
+        }
+        #endregion
+
+        #region 两端本地端口连接事件通知
+        /// <summary>
+        /// 当客户端本地端口连接
+        /// </summary>
+        /// <param name="uid"></param>
+        /// <param name="tunnelId"></param>
+        public void OnClientLocalConnect(byte tunnelId,byte _Idx)
+        {
+            AppNoSugarNet.log.Debug($"OnClientLocalConnect {tunnelId},{_Idx}");
+            if (!mDictTunnelID2Cfg.ContainsKey(tunnelId))
+                return;
+
+            byte[] respData = ProtoBufHelper.Serizlize(new Protobuf_C2S_Connect()
+            {
+                TunnelID = tunnelId,
+                Idx = _Idx,
+            });
+            
+            //告知给服务端，来自客户端本地的连接建立
+            AppNoSugarNet.networkHelper.SendToServer((int)CommandID.CmdTunnelC2SConnect, respData);
+        }
+        /// <summary>
+        /// 当客户端本地端口连接断开
+        /// </summary>
+        /// <param name="uid"></param>
+        /// <param name="tunnelId"></param>
+        public void OnClientLocalDisconnect(byte tunnelId, byte _Idx)
+        {
+            AppNoSugarNet.log.Debug($"OnClientLocalDisconnect {tunnelId},{_Idx}");
+            //隧道ID定位投递服务端本地连接
+            if (!mDictTunnelID2Cfg.ContainsKey(tunnelId))
+                return;
+
+            byte[] respData = ProtoBufHelper.Serizlize(new Protobuf_C2S_Disconnect()
+            {
+                TunnelID = tunnelId,
+                Idx= _Idx,
+            });
+
+            //告知给服务端，来自客户端本地的连接断开
+            AppNoSugarNet.networkHelper.SendToServer((int)CommandID.CmdTunnelC2SDisconnect, respData);
+        }
+
+        /// <summary>
+        /// 当服务端本地端口连接
+        /// </summary>
+        /// <param name="tunnelId"></param>
+        public void OnServerLocalConnect(byte tunnelId,byte Idx)
+        {
+            AppNoSugarNet.log.Debug($"OnServerLocalConnect {tunnelId},{Idx}");
+            if (!GetLocalListener(tunnelId, out LocalListener _listener))
+                return;
+            //维护状态
+            _listener.SetRemoteConnectd(Idx, true);
+            if (_listener.GetDictMsgQueue(Idx, out List<IdxWithMsg> msglist))
+            {
+                for(int i = 0; i < msglist.Count; i++) 
+                {
+                    IdxWithMsg msg = msglist[i];
+                    //投递给服务端，来自客户端本地的连接数据
+                    AppNoSugarNet.networkHelper.SendToServer((int)CommandID.CmdTunnelC2SData, msg.data);
+                    //发送后回收
+                    AppNoSugarNet.local._localMsgPool.Enqueue(msg);
+                }
+            }
+        }
+        /// <summary>
+        /// 当服务端本地端口连接断开
+        /// </summary>
+        /// <param name="uid"></param>
+        /// <param name="tunnelId"></param>
+        public void OnServerLocalDisconnect(byte tunnelId, byte Idx)
+        {
+            AppNoSugarNet.log.Debug($"OnServerLocalDisconnect {tunnelId},{Idx}");
+            if (!GetLocalListener(tunnelId, out LocalListener _listener))
+                return;
+            _listener.SetRemoteConnectd(Idx,false);
+            _listener.CloseConnectByIdx(Idx);
+        }
+        #endregion
+
+        #region 数据投递
+        /// <summary>
+        /// 来自服务端本地连接投递的Tunnel数据
+        /// </summary>
+        /// <param name="uid"></param>
+        /// <param name="tunnelId"></param>
+        /// <param name="data"></param>
+        public void OnServerLocalDataCallBack(byte tunnelId,byte Idx, byte[] data)
+        {
+            //AppNoSugarNet.log.Info($"OnServerLocalDataCallBack {tunnelId},{Idx},Data长度：{data.Length}");
+            if (!GetLocalListener(tunnelId, out LocalListener _listener))
+                return;
+            //记录压缩前数据长度
+            tReciveAllLenght += data.Length;
+            //解压
+            data = mCompressAdapter.Decompress(data);
+            _listener.SendSocketByIdx(Idx,data);
+        }
+        /// <summary>
+        /// 来自客户端本地连接投递的Tunnel数据
+        /// </summary>
+        /// <param name="uid"></param>
+        /// <param name="tunnelId"></param>
+        /// <param name="data"></param>
+        public void OnClientTunnelDataCallBack(byte tunnelId,byte Idx, byte[] data)
+        {
+            //AppNoSugarNet.log.Info($"OnClientTunnelDataCallBack {tunnelId},{Idx}");
+
+            int SlienLenght = 1000;
+            //判断数据量大时分包
+            if (data.Length > SlienLenght)
+            {
+                byte[] tempSpan = data;
+                byte[] tempSpanSlien = null;
+                int PageCount = (int)(data.Length / SlienLenght);
+                if (data.Length % SlienLenght > 0)
+                {
+                    PageCount++;
+                }
+
+                for (int i = 0; i < PageCount; i++)
+                {
+                    tempSpanSlien = new byte[SlienLenght];
+                    int StartIdx = i * SlienLenght;
+                    if (i != PageCount - 1)//不是最后一个包
+                        Array.Copy(tempSpan, StartIdx, tempSpanSlien, 0, SlienLenght);
+                    else//最后一个
+                        Array.Copy(tempSpan, StartIdx, tempSpanSlien, 0, tempSpanSlien.Length - StartIdx);
+
+                    SendDataToRemote(tunnelId, Idx, tempSpanSlien);
+
+                    /*if (i != PageCount - 1)//不是最后一个包
+                        tempSpanSlien = tempSpan.Slice(StartIdx, SlienLenght);
+                    else//最后一个
+                        tempSpanSlien = tempSpan.Slice(StartIdx);
+
+                    SendDataToRemote(tunnelId, Idx, tempSpanSlien.ToArray());*/
+                }
+                return;
+            }
+            SendDataToRemote(tunnelId, Idx, data);
+        }
+
+        void SendDataToRemote(byte tunnelId, byte Idx, byte[] data)
+        {
+            //压缩
+            data = mCompressAdapter.Compress(data);
+            //记录压缩后数据长度
+            tSendAllLenght += data.Length;
+
+            byte[] respData = ProtoBufHelper.Serizlize(new Protobuf_C2S_DATA()
+            {
+                TunnelID = tunnelId,
+                Idx = Idx,
+                HunterNetCoreData = ByteString.CopyFrom(data)
+            });
+
+            if (!GetLocalListener(tunnelId, out LocalListener _listener))
+                return;
+
+            //远程未连接，添加到缓存
+            if (!_listener.CheckRemoteConnect(Idx))
+            {
+                _listener.EnqueueIdxWithMsg(Idx, respData);
+                return;
+            }
+            //投递给服务端，来自客户端本地的连接数据
+            AppNoSugarNet.networkHelper.SendToServer((int)CommandID.CmdTunnelC2SData, respData);
+        }
+        #endregion
+
+    }
+}

NoSugarNet.ClientCore.Standard2/Manager/AppLogin.cs

@@ -0,0 +1,38 @@
+using AxibugProtobuf;
+using NoSugarNet.ClientCoreNet.Standard2.Common;
+using NoSugarNet.ClientCoreNet.Standard2.Network;
+
+namespace NoSugarNet.ClientCoreNet.Standard2.Manager
+{
+    public class AppLogin
+    {
+        public AppLogin()
+        {
+            NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdLogin, RecvLoginMsg);
+        }
+        public void Login(string Account)
+        {
+            Protobuf_Login msg = new Protobuf_Login()
+            {
+                LoginType = 0,
+                Account = Account,
+            };
+            AppNoSugarNet.networkHelper.SendToServer((int)CommandID.CmdLogin, ProtoBufHelper.Serizlize(msg));
+        }
+
+        public void RecvLoginMsg(byte[] reqData)
+        {
+            Protobuf_Login_RESP msg = ProtoBufHelper.DeSerizlize<Protobuf_Login_RESP>(reqData);
+            if (msg.Status == LoginResultStatus.Ok)
+            {
+                AppNoSugarNet.log.Info("登录成功");
+                AppNoSugarNet.user.InitMainUserData(AppNoSugarNet.user.userdata.Account);
+            }
+            else
+            {
+                AppNoSugarNet.log.Info("登录失败");
+            }
+        }
+
+    }
+}

NoSugarNet.ClientCore.Standard2/Manager/LocalClient/LocalListener.cs

@@ -0,0 +1,264 @@
+using HaoYueNet.ServerNetwork.Standard2;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Sockets;
+
+namespace NoSugarNet.ClientCoreNet.Standard2
+{
+    public class LocalListener : TcpSaeaServer_SourceMode
+    {
+        public byte mTunnelID;
+        public long mReciveAllLenght;
+        public long mSendAllLenght;
+        public LocalListener(int numConnections, int receiveBufferSize, byte TunnelID)
+            : base(numConnections, receiveBufferSize)
+        {
+            OnClientNumberChange += ClientNumberChange;
+            OnReceive += ReceiveData;
+            OnDisconnected += OnDisconnect;
+            OnNetLog += OnShowNetLog;
+
+            mTunnelID = TunnelID;
+        }
+
+        private void ClientNumberChange(int num, AsyncUserToken token)
+        {
+            AppNoSugarNet.log.Info("Client数发生变化");
+            //增加连接数
+            if (num > 0)
+            {
+                int Idx = AddDictSocket(token.Socket);
+                if (GetSocketByIdx(Idx, out LocalClientInfo _localClientInf))
+                {
+                    AppNoSugarNet.local.OnClientLocalConnect(mTunnelID, (byte)Idx);
+                }
+            }
+        }
+
+        /// <summary>
+        /// 通过下标发送
+        /// </summary>
+        /// <param name="Idx"></param>
+        /// <param name="data"></param>
+        public void SendSocketByIdx(int Idx, byte[] data)
+        {
+            if (GetSocketByIdx(Idx, out LocalClientInfo _localClientInfo))
+            {
+                mSendAllLenght += data.Length;
+                SendToSocket(_localClientInfo._socket, data);
+            }
+            //TODO连接前缓存数据
+        }
+
+        /// <summary>
+        /// 接受包回调
+        /// </summary>
+        /// <param name="CMDID">协议ID</param>
+        /// <param name="ERRCODE">错误编号</param>
+        /// <param name="data">业务数据</param>
+        private void ReceiveData(AsyncUserToken token, byte[] data)
+        {
+            DataCallBack(token.Socket, data);
+        }
+
+        public void DataCallBack(Socket sk, byte[] data)
+        {
+            //AppNoSugarNet.log.Info("收到消息 数据长度=>" + data.Length);
+            //记录接受长度
+            mReciveAllLenght += data.Length;
+            if (!GetSocketIdxBySocket(sk, out int Idx))
+                return;
+            try
+            {
+                //抛出网络数据
+                AppNoSugarNet.local.OnClientTunnelDataCallBack(mTunnelID, (byte)Idx, data);
+            }
+            catch (Exception ex)
+            {
+                AppNoSugarNet.log.Info("逻辑处理错误：" + ex.ToString());
+            }
+        }
+
+        public void CloseConnectByIdx(byte Idx)
+        {
+            if (GetSocketByIdx(Idx, out LocalClientInfo _localClientInf))
+            {
+                _localClientInf._socket.Shutdown(SocketShutdown.Both);
+            }
+        }
+
+        /// <summary>
+        /// 断开连接
+        /// </summary>
+        /// <param name="sk"></param>
+        public void OnDisconnect(AsyncUserToken token)
+        {
+            AppNoSugarNet.log.Info("断开连接");
+
+            if (!GetSocketIdxBySocket(token.Socket, out int Idx))
+                return;
+
+            AppNoSugarNet.local.OnClientLocalDisconnect(mTunnelID, (byte)Idx);
+            RemoveDictSocket(token.Socket);
+        }
+
+        public void OnShowNetLog(string msg)
+        {
+            AppNoSugarNet.log.Info(msg);
+        }
+
+        #region 一个轻量级无用户连接管理
+        Dictionary<IntPtr, int> DictSocketHandle2Idx = new Dictionary<IntPtr, int>();
+        Dictionary<int, LocalClientInfo> DictIdx2LocalClientInfo = new Dictionary<int, LocalClientInfo>();
+        int mSeedIdx = 0;
+        List<int> FreeIdxs = new List<int>();
+        public class LocalClientInfo
+        {
+            public Socket _socket;
+            public bool bRemoteConnect;
+            public bool bLocalConnect => _socket.Connected;
+            public Queue<IdxWithMsg> msgQueue = new Queue<IdxWithMsg>();
+        }
+
+        int GetNextIdx()
+        {
+            if (FreeIdxs.Count > 0)
+            {
+                int Idx = FreeIdxs[0];
+                FreeIdxs.RemoveAt(0);
+                return Idx;
+            }
+            return mSeedIdx++;
+        }
+
+        /// <summary>
+        /// 追加Socket返回下标
+        /// </summary>
+        /// <param name="socket"></param>
+        /// <returns></returns>
+        public int AddDictSocket(Socket socket)
+        {
+            if (socket == null)
+                return -1;
+            lock (DictSocketHandle2Idx)
+            {
+                int Idx = GetNextIdx();
+                DictSocketHandle2Idx[socket.Handle] = Idx;
+                DictIdx2LocalClientInfo[Idx] = new LocalClientInfo() { _socket = socket,bRemoteConnect = false};
+                return Idx;
+            }
+        }
+
+        public void RemoveDictSocket(Socket socket)
+        {
+            if (socket == null)
+                return;
+            lock (DictSocketHandle2Idx)
+            {
+                if (!DictSocketHandle2Idx.ContainsKey(socket.Handle))
+                    return;
+                int Idx = DictSocketHandle2Idx[socket.Handle];
+                FreeIdxs.Add(Idx);
+                if (DictIdx2LocalClientInfo.ContainsKey(Idx))
+                    DictIdx2LocalClientInfo.Remove(Idx);
+                DictSocketHandle2Idx.Remove(socket.Handle);
+            }
+        }
+
+        bool GetSocketByIdx(int Idx, out LocalClientInfo _localClientInfo)
+        {
+            if (!DictIdx2LocalClientInfo.ContainsKey(Idx))
+            {
+                _localClientInfo = null;
+                return false;
+            }
+
+            _localClientInfo = DictIdx2LocalClientInfo[Idx];
+            return true;
+        }
+
+        public bool GetSocketIdxBySocket(Socket _socket, out int Idx)
+        {
+            if (_socket == null)
+            {
+                Idx = -1;
+                return false;
+            }
+
+            if (!DictSocketHandle2Idx.ContainsKey(_socket.Handle))
+            {
+                Idx = -1;
+                return false;
+            }
+
+            Idx = DictSocketHandle2Idx[_socket.Handle];
+            return true;
+        }
+
+        public bool CheckRemoteConnect(int Idx)
+        {
+            if (!GetSocketByIdx(Idx, out LocalClientInfo _localClientInfo))
+                return false;
+            return _localClientInfo.bRemoteConnect;
+        }
+
+        public void SetRemoteConnectd(int Idx,bool bConnected)
+        {
+            if (!GetSocketByIdx(Idx, out LocalClientInfo _localClientInfo))
+                return;
+            if (bConnected)
+                AppNoSugarNet.log.Info("远端本地连接已连接！！！！");
+            else
+                AppNoSugarNet.log.Info("远端本地连接已断开连接！！！！");
+            _localClientInfo.bRemoteConnect = bConnected;
+        }
+
+        public void StopAll()
+        {
+            lock (DictIdx2LocalClientInfo)
+            {
+                int[] Idxs =  DictIdx2LocalClientInfo.Keys.ToArray();
+                for (int i = 0; i < Idxs.Length; i++)
+                {
+                    CloseConnectByIdx((byte)Idxs[i]);
+                }
+                DictIdx2LocalClientInfo.Clear();
+            }
+        }
+
+        #endregion
+
+        #region 缓存
+        public void EnqueueIdxWithMsg(byte Idx, byte[] data)
+        {
+            if (!GetSocketByIdx(Idx, out LocalClientInfo _localClientInfo))
+                return;
+
+            IdxWithMsg Msg = AppNoSugarNet.local._localMsgPool.Dequeue();
+            Msg.Idx = Idx;
+            Msg.data = data;
+            _localClientInfo.msgQueue.Enqueue(Msg);
+        }
+        public bool GetDictMsgQueue(byte Idx,out List<IdxWithMsg> MsgList)
+        {
+            if (!GetSocketByIdx(Idx, out LocalClientInfo _localClientInfo) || _localClientInfo.msgQueue.Count < 1)
+            {
+                MsgList = null;
+                return false;
+            }
+
+            MsgList = new List<IdxWithMsg>();
+            lock (_localClientInfo.msgQueue)
+            {
+                while (_localClientInfo.msgQueue.Count > 0)
+                {
+                    IdxWithMsg msg = _localClientInfo.msgQueue.Dequeue();
+                    MsgList.Add(msg);
+                }
+                return true;
+            }
+        }
+        #endregion
+    }
+}

NoSugarNet.ClientCore.Standard2/Manager/LocalClient/LocalListener_Source.cs

@@ -0,0 +1,292 @@
+using HaoYueNet.ClientNetworkNet.Standard2.OtherMode;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Sockets;
+
+namespace NoSugarNet.ClientCoreNet.Standard2
+{
+    public class LocalListener_Source : NetworkHelperCore_ListenerMode
+    {
+        public byte mTunnelID;
+        public long mReciveAllLenght;
+        public long mSendAllLenght;
+        public LocalListener_Source(int numConnections, int receiveBufferSize, byte TunnelID)
+            : base()
+        {
+            OnConnected += ClientNumberChange;
+            OnReceive += ReceiveData;
+            OnDisconnected += OnDisconnectClient;
+            OnNetLog += OnShowNetLog;
+
+            mTunnelID = TunnelID;
+        }
+
+        private void ClientNumberChange(Socket socket)
+        {
+            AppNoSugarNet.log.Info("Client数发生变化");
+            //增加连接数
+            int Idx = AddDictSocket(socket);
+            if (GetSocketByIdx(Idx, out LocalClientInfo _localClientInf))
+            {
+                AppNoSugarNet.local.OnClientLocalConnect(mTunnelID, (byte)Idx);
+            }
+        }
+
+        /// <summary>
+        /// 通过下标发送
+        /// </summary>
+        /// <param name="Idx"></param>
+        /// <param name="data"></param>
+        public void SendSocketByIdx(int Idx, byte[] data)
+        {
+            if (GetSocketByIdx(Idx, out LocalClientInfo _localClientInfo))
+            {
+                mSendAllLenght += data.Length;
+                SendToClient(_localClientInfo._socket, data);
+            }
+            //TODO连接前缓存数据
+        }
+
+        /// <summary>
+        /// 接受包回调
+        /// </summary>
+        /// <param name="CMDID">协议ID</param>
+        /// <param name="ERRCODE">错误编号</param>
+        /// <param name="data">业务数据</param>
+        private void ReceiveData(Socket sk, byte[] data)
+        {
+            DataCallBack(sk, data);
+        }
+
+        public void DataCallBack(Socket sk, byte[] data)
+        {
+            //AppNoSugarNet.log.Info("收到消息 数据长度=>" + data.Length);
+            //记录接受长度
+            mReciveAllLenght += data.Length;
+            if (!GetSocketIdxBySocket(sk, out int Idx))
+                return;
+            try
+            {
+                if (GetMsgQueueByIdx(sk.Handle, out Queue<byte[]> _queue))
+                {
+                    lock (_queue) 
+                    {
+                        _queue.Enqueue(data);
+                        while (_queue.Count > 0)
+                        { 
+                            AppNoSugarNet.local.OnClientTunnelDataCallBack(mTunnelID, (byte)Idx, _queue.Dequeue());
+                        }
+                    }
+                }
+
+                ////抛出网络数据
+                //AppNoSugarNet.local.OnClientTunnelDataCallBack(mTunnelID, (byte)Idx, data);
+            }
+            catch (Exception ex)
+            {
+                AppNoSugarNet.log.Info("逻辑处理错误：" + ex.ToString());
+            }
+        }
+
+        public void CloseConnectByIdx(byte Idx)
+        {
+            if (GetSocketByIdx(Idx, out LocalClientInfo _localClientInf))
+            {
+                _localClientInf._socket.Shutdown(SocketShutdown.Both);
+            }
+        }
+
+        /// <summary>
+        /// 断开连接
+        /// </summary>
+        /// <param name="sk"></param>
+        public void OnDisconnectClient(Socket sk)
+        {
+            AppNoSugarNet.log.Info("断开连接");
+
+            if (!GetSocketIdxBySocket(sk, out int Idx))
+                return;
+
+            AppNoSugarNet.local.OnClientLocalDisconnect(mTunnelID, (byte)Idx);
+            RemoveDictSocket(sk);
+        }
+
+        public void OnShowNetLog(string msg)
+        {
+            AppNoSugarNet.log.Info(msg);
+        }
+
+        #region 一个轻量级无用户连接管理
+        Dictionary<IntPtr, int> DictSocketHandle2Idx = new Dictionary<IntPtr, int>();
+        Dictionary<IntPtr, Queue<byte[]>> DictSocketHandle2Msg = new Dictionary<IntPtr, Queue<byte[]>>();
+        Dictionary<int, LocalClientInfo> DictIdx2LocalClientInfo = new Dictionary<int, LocalClientInfo>();
+        int mSeedIdx = 0;
+        List<int> FreeIdxs = new List<int>();
+        public class LocalClientInfo
+        {
+            public Socket _socket;
+            public bool bRemoteConnect;
+            public bool bLocalConnect => _socket.Connected;
+            public Queue<IdxWithMsg> msgQueue = new Queue<IdxWithMsg>();
+        }
+
+        int GetNextIdx()
+        {
+            if (FreeIdxs.Count > 0)
+            {
+                int Idx = FreeIdxs[0];
+                FreeIdxs.RemoveAt(0);
+                return Idx;
+            }
+            return mSeedIdx++;
+        }
+
+        /// <summary>
+        /// 追加Socket返回下标
+        /// </summary>
+        /// <param name="socket"></param>
+        /// <returns></returns>
+        public int AddDictSocket(Socket socket)
+        {
+            if (socket == null)
+                return -1;
+            lock (DictSocketHandle2Idx)
+            {
+                int Idx = GetNextIdx();
+                DictSocketHandle2Idx[socket.Handle] = Idx;
+                DictIdx2LocalClientInfo[Idx] = new LocalClientInfo() { _socket = socket,bRemoteConnect = false};
+                DictSocketHandle2Msg[socket.Handle] = new Queue<byte[]>();
+                return Idx;
+            }
+        }
+
+        public void RemoveDictSocket(Socket socket)
+        {
+            if (socket == null)
+                return;
+            lock (DictSocketHandle2Idx)
+            {
+                if (!DictSocketHandle2Idx.ContainsKey(socket.Handle))
+                    return;
+                int Idx = DictSocketHandle2Idx[socket.Handle];
+                FreeIdxs.Add(Idx);
+                if (DictIdx2LocalClientInfo.ContainsKey(Idx))
+                    DictIdx2LocalClientInfo.Remove(Idx);
+                
+                if (DictSocketHandle2Msg.ContainsKey(socket.Handle))
+                    DictSocketHandle2Msg.Remove(socket.Handle);
+
+                DictSocketHandle2Idx.Remove(socket.Handle);
+            }
+        }
+
+        bool GetSocketByIdx(int Idx, out LocalClientInfo _localClientInfo)
+        {
+            if (!DictIdx2LocalClientInfo.ContainsKey(Idx))
+            {
+                _localClientInfo = null;
+                return false;
+            }
+
+            _localClientInfo = DictIdx2LocalClientInfo[Idx];
+            return true;
+        }
+
+        bool GetMsgQueueByIdx(IntPtr handle, out Queue<byte[]> _queue)
+        {
+            if (!DictSocketHandle2Msg.ContainsKey(handle))
+            {
+                _queue = null;
+                return false;
+            }
+
+            _queue = DictSocketHandle2Msg[handle];
+            return true;
+        }
+
+        public bool GetSocketIdxBySocket(Socket _socket, out int Idx)
+        {
+            if (_socket == null)
+            {
+                Idx = -1;
+                return false;
+            }
+
+            if (!DictSocketHandle2Idx.ContainsKey(_socket.Handle))
+            {
+                Idx = -1;
+                return false;
+            }
+
+            Idx = DictSocketHandle2Idx[_socket.Handle];
+            return true;
+        }
+
+        public bool CheckRemoteConnect(int Idx)
+        {
+            if (!GetSocketByIdx(Idx, out LocalClientInfo _localClientInfo))
+                return false;
+            return _localClientInfo.bRemoteConnect;
+        }
+
+        public void SetRemoteConnectd(int Idx,bool bConnected)
+        {
+            if (!GetSocketByIdx(Idx, out LocalClientInfo _localClientInfo))
+                return;
+            if (bConnected)
+                AppNoSugarNet.log.Info("远端本地连接已连接！！！！");
+            else
+                AppNoSugarNet.log.Info("远端本地连接已断开连接！！！！");
+            _localClientInfo.bRemoteConnect = bConnected;
+        }
+
+        public void StopAll()
+        {
+            lock (DictIdx2LocalClientInfo)
+            {
+                int[] Idxs =  DictIdx2LocalClientInfo.Keys.ToArray();
+                for (int i = 0; i < Idxs.Length; i++)
+                {
+                    CloseConnectByIdx((byte)Idxs[i]);
+                }
+                DictIdx2LocalClientInfo.Clear();
+            }
+        }
+
+        #endregion
+
+
+        #region 缓存
+        public void EnqueueIdxWithMsg(byte Idx, byte[] data)
+        {
+            if (!GetSocketByIdx(Idx, out LocalClientInfo _localClientInfo))
+                return;
+
+            IdxWithMsg Msg = AppNoSugarNet.local._localMsgPool.Dequeue();
+            Msg.Idx = Idx;
+            Msg.data = data;
+            _localClientInfo.msgQueue.Enqueue(Msg);
+        }
+        public bool GetDictMsgQueue(byte Idx,out List<IdxWithMsg> MsgList)
+        {
+            if (!GetSocketByIdx(Idx, out LocalClientInfo _localClientInfo) || _localClientInfo.msgQueue.Count < 1)
+            {
+                MsgList = null;
+                return false;
+            }
+
+            MsgList = new List<IdxWithMsg>();
+            lock (_localClientInfo.msgQueue)
+            {
+                while (_localClientInfo.msgQueue.Count > 0)
+                {
+                    IdxWithMsg msg = _localClientInfo.msgQueue.Dequeue();
+                    MsgList.Add(msg);
+                }
+                return true;
+            }
+        }
+        #endregion
+    }
+}

NoSugarNet.ClientCore.Standard2/Manager/LocalClient/LocalMsgQueuePool.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+
+namespace NoSugarNet.ClientCoreNet.Standard2
+{
+    public class IdxWithMsg
+    {
+        public byte Idx;
+        public byte[] data;
+    }
+
+    public class LocalMsgQueuePool
+    {
+        Queue<IdxWithMsg> msg_pool;
+
+        public LocalMsgQueuePool(int capacity)
+        {
+            msg_pool = new Queue<IdxWithMsg>(capacity);
+        }
+
+        /// <summary>
+        /// 向 Queue 的末尾添加一个对象。
+        /// </summary>
+        /// <param name="item"></param>
+        public void Enqueue(IdxWithMsg item)
+        {
+            lock (msg_pool)
+            {
+                item.Idx = 0;
+                item.data = null;
+                msg_pool.Enqueue(item);
+            }
+        }
+
+        //移除并返回在 Queue 的开头的对象。
+        public IdxWithMsg Dequeue()
+        {
+            lock (msg_pool)
+            {
+                if(msg_pool.Count > 0)
+                    return msg_pool.Dequeue();
+                return new IdxWithMsg();
+            }
+        }
+
+        public int Count
+        {
+            get { return msg_pool.Count; }
+        }
+
+        public void Clear()
+        {
+            msg_pool.Clear();
+        }
+    }
+}

NoSugarNet.ClientCore.Standard2/Manager/LogManager.cs

@@ -0,0 +1,48 @@
+namespace NoSugarNet.ClientCoreNet.Standard2.Manager
+{
+    public class LogManager
+    {
+        public enum E_LogType:byte
+        {
+            Info = 0,
+            Debug = 1,
+            Warning = 2,
+            Error = 3,
+        }
+        /// <summary>
+        /// 日志
+        /// </summary>
+        /// <param name="sk"></param>
+        public delegate void OnLogHandler(int debuglv,string msg);
+
+        /// <summary>  
+        /// 内部输出
+        /// </summary>
+        public static event OnLogHandler OnLog;
+
+        public void Info(string str)
+        {
+            Log(E_LogType.Info, str);
+        }
+
+        public void Debug(string str)
+        {
+            Log(E_LogType.Debug, str);
+        }
+
+        public void Warning(string str)
+        {
+            Log(E_LogType.Warning, str);
+        }
+
+        public void Error(string str)
+        {
+            Log(E_LogType.Error, str);
+        }
+
+        public void Log(E_LogType logtype,string str)
+        {
+            OnLog?.Invoke((int)logtype, str);
+        }
+    }
+}

NoSugarNet.ClientCore.Standard2/Manager/UserDataManager.cs

@@ -0,0 +1,56 @@
+using AxibugProtobuf;
+
+namespace NoSugarNet.ClientCoreNet.Standard2.Manager
+{
+    public class UserDataBase
+    {
+        public long UID { get; set; }
+        public string Account { get; set; }
+    }
+
+    public class MainUserDataBase : UserDataBase
+    {
+        public bool IsLoggedIn { get; set; } = false;
+    }
+
+    public class UserDataManager
+    {
+        public UserDataManager()
+        {
+            //注册重连成功事件，以便后续自动登录
+            AppNoSugarNet.networkHelper.OnReConnected += OnReConnected;
+        }
+        public MainUserDataBase userdata { get;private set; } = new MainUserDataBase();
+        public bool IsLoggedIn => userdata.IsLoggedIn;
+
+        public void InitMainUserData(string UName)
+        {
+            userdata.Account = UName;
+            userdata.IsLoggedIn = true;
+            //以及其他数据初始化
+            //...
+        }
+
+        /// <summary>
+        /// 登出
+        /// </summary>
+        public void LoginOutData()
+        {
+            userdata.IsLoggedIn = false;
+            //以及其他数据清理
+            //...
+        }
+
+        /// <summary>
+        /// 当重连成功
+        /// </summary>
+        public void OnReConnected()
+        {
+            //如果之前已登录，则重新登录
+            if (userdata.IsLoggedIn)
+            {
+                AppNoSugarNet.login.Login(userdata.Account);
+            }
+        }
+    }
+}

NoSugarNet.ClientCore.Standard2/NetStatus.cs

@@ -0,0 +1,16 @@
+namespace NoSugarNet.ClientCoreNet.Standard2
+{
+    public struct NetStatus
+    {
+        public int ClientUserCount;
+        public int TunnelCount;
+        public long srcReciveAllLenght;
+        public long srcSendAllLenght;
+        public long srcReciveSecSpeed;
+        public long srcSendSecSpeed;
+        public long tReciveAllLenght;
+        public long tSendAllLenght;
+        public long tReciveSecSpeed;
+        public long tSendSecSpeed;
+    }
+}

NoSugarNet.ClientCore.Standard2/Network/NetMsg.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+
+namespace NoSugarNet.ClientCoreNet.Standard2.Network
+{
+
+    public class NetMsg
+    {
+        private static NetMsg instance = new NetMsg();
+        public static NetMsg Instance { get { return instance; } }
+
+        private Dictionary<int, List<Delegate>> netEventDic = new Dictionary<int, List<Delegate>>(128);
+
+        private NetMsg() { }
+
+
+        #region RegisterMsgEvent
+
+        public void RegNetMsgEvent(int cmd, Action<byte[]> callback)
+        {
+            InterRegNetMsgEvent(cmd, callback);
+        }
+
+        private void InterRegNetMsgEvent(int cmd, Delegate callback)
+        {
+            if (netEventDic.ContainsKey(cmd))
+            {
+                if (netEventDic[cmd].IndexOf(callback) < 0)
+                {
+                    netEventDic[cmd].Add(callback);
+                }
+            }
+            else
+            {
+                netEventDic.Add(cmd, new List<Delegate>() { callback });
+            }
+        }
+        #endregion
+
+        #region UnregisterCMD
+
+        public void UnregisterCMD(int evt, Action<byte[]> callback)
+        {
+            Delegate tempDelegate = callback;
+            InterUnregisterCMD(evt, tempDelegate);
+        }
+
+        private void InterUnregisterCMD(int cmd, Delegate callback)
+        {
+            if (netEventDic.ContainsKey(cmd))
+            {
+                netEventDic[cmd].Remove(callback);
+                if (netEventDic[cmd].Count == 0) netEventDic.Remove(cmd);
+            }
+        }
+        #endregion
+
+        #region PostEvent
+        public void PostNetMsgEvent(int cmd, byte[] arg)
+        {
+            List<Delegate> eventList = GetNetEventDicList(cmd);
+            if (eventList != null)
+            {
+                foreach (Delegate callback in eventList)
+                {
+                    try
+                    {
+                        ((Action<byte[]>)callback)(arg);
+                    }
+                    catch (Exception e)
+                    {
+                        AppNoSugarNet.log.Error(e.Message);
+                    }
+                }
+            }
+        }
+        #endregion
+
+        /// <summary>
+        /// 获取所有事件
+        /// </summary>
+        /// <param name="cmd"></param>
+        /// <returns></returns>
+        private List<Delegate> GetNetEventDicList(int cmd)
+        {
+            if (netEventDic.ContainsKey(cmd))
+            {
+                List<Delegate> tempList = netEventDic[cmd];
+                if (null != tempList)
+                {
+                    return tempList;
+                }
+            }
+            return null;
+        }
+    }
+}

NoSugarNet.ClientCore.Standard2/Network/NetworkHelper.cs

@@ -0,0 +1,125 @@
+using HaoYueNet.ClientNetworkNet.Standard2;
+using System;
+using System.Threading;
+
+namespace NoSugarNet.ClientCoreNet.Standard2.Network
+{
+    /// <summary>
+    /// 继承网络库，以支持网络功能
+    /// </summary>
+    public class NetworkHelper : NetworkHelperCore
+    {
+        public NetworkHelper()
+        {
+            //指定接收服务器数据事件
+            OnReceiveData += GetDataCallBack;
+            //断开连接
+            OnClose += OnConnectClose;
+            OnConnected += NetworkConnected;
+            //网络库调试信息输出事件，用于打印网络内容
+            OnLogOut += NetworkDeBugLog;
+        }
+
+        public delegate void OnReConnectedHandler();
+        /// <summary>
+        /// 重连成功事件
+        /// </summary>
+        public event OnReConnectedHandler OnReConnected;
+        /// <summary>
+        /// 是否自动重连
+        /// </summary>
+        public bool bAutoReConnect = false;
+        /// <summary>
+        /// 重连尝试时间
+        /// </summary>
+        const int ReConnectTryTime = 1000;
+
+        public void NetworkConnected(bool IsConnect)
+        {
+            NetworkDeBugLog($"NetworkConnected:{IsConnect}");
+            if (IsConnect)
+            {
+                AppNoSugarNet.login.Login(Guid.NewGuid().ToString());
+            }
+            else
+            {
+                //连接失败
+                NetworkDeBugLog("连接失败！");
+                //自动重连开关
+                if (bAutoReConnect)
+                    ReConnect();
+            }
+        }
+
+        public void NetworkDeBugLog(string str)
+        {
+            //用于Unity内的输出
+            //Debug.Log("NetCoreDebug >> "+str);
+            AppNoSugarNet.log.Info("NetCoreDebug >> " + str);
+        }
+
+        /// <summary>
+        /// 接受包回调
+        /// </summary>
+        /// <param name="CMDID">协议ID</param>
+        /// <param name="ERRCODE">错误编号</param>
+        /// <param name="data">业务数据</param>
+        public void GetDataCallBack(int CMDID, int ERRCODE, byte[] data)
+        {
+            //NetworkDeBugLog("收到消息 CMDID =>" + CMDID + " ERRCODE =>" + ERRCODE + " 数据长度=>" + data.Length);
+            try
+            {
+                //抛出网络数据
+                NetMsg.Instance.PostNetMsgEvent(CMDID, data);
+            }
+            catch (Exception ex)
+            {
+                NetworkDeBugLog("逻辑处理错误：" + ex.ToString());
+            }
+        }
+
+        /// <summary>
+        /// 关闭连接
+        /// </summary>
+        public void OnConnectClose()
+        {
+            NetworkDeBugLog("OnConnectClose");
+
+            //停止所有
+            AppNoSugarNet.local.StopAll();
+
+            //自动重连开关
+            if (bAutoReConnect)
+                ReConnect();
+        }
+
+
+        bool bInReConnecting = false;
+        /// <summary>
+        /// 自动重连
+        /// </summary>
+        void ReConnect()
+        {
+            if (bInReConnecting)
+                return;
+            bInReConnecting = true;
+
+            bool bflagDone = false;
+            do
+            {
+                //等待时间
+                Thread.Sleep(ReConnectTryTime);
+                AppNoSugarNet.log.Info($"尝试自动重连{LastConnectIP}:{LastConnectPort}……");
+                //第一步
+                if (Init(LastConnectIP, LastConnectPort))
+                {
+                    AppNoSugarNet.log.Info($"自动重连成功!");
+                    bflagDone = true;
+                    AppNoSugarNet.log.Info($"触发重连后的自动逻辑!");
+                    OnReConnected?.Invoke();
+                }
+            } while (!bflagDone);
+            bInReConnecting = false;
+        }
+    }
+}

NoSugarNet.ClientCore.Standard2/NoSugarNet.ClientCore.Standard2.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+  </PropertyGroup>
+  <PropertyGroup>
+	<!--避免 错误	CS8630	无效的 nullable 值: C# 7.3 的“Enable”。请使用语言版本 8.0 或更高版本 -->
+   <LangVersion>8.0</LangVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="System.Memory" Version="4.5.5" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="Google.Protobuf">
+      <HintPath>..\Lib\Google.Protobuf.dll</HintPath>
+    </Reference>
+    <Reference Include="HaoYueNet.ClientNetworkNet.Standard2">
+      <HintPath>..\Lib\NetLib_Standard2\HaoYueNet.ClientNetworkNet.Standard2.dll</HintPath>
+    </Reference>
+    <Reference Include="HaoYueNet.ServerNetwork.Standard2">
+      <HintPath>..\Lib\NetLib_Standard2\HaoYueNet.ServerNetwork.Standard2.dll</HintPath>
+    </Reference>
+    <Reference Include="NoSugarNet.DataHelper">
+      <HintPath>..\Lib\NetLib_Standard2\NoSugarNet.DataHelper.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+</Project>

NoSugarNet.ClientCore.Standard2/NoSugarNet.ClientCore.Standard2.csproj.user

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <_LastSelectedProfileId>F:\Sin365\NoSugarNet\NoSugarNet.ClientCore.Standard2\Properties\PublishProfiles\FolderProfile.pubxml</_LastSelectedProfileId>
+  </PropertyGroup>
+</Project>

NoSugarNet.ClientCore.Standard2/Properties/PublishProfiles/FolderProfile.pubxml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+https://go.microsoft.com/fwlink/?LinkID=208121.
+-->
+<Project>
+  <PropertyGroup>
+    <Configuration>Release</Configuration>
+    <Platform>Any CPU</Platform>
+    <PublishDir>bin\Release\netstandard2.0\publish\</PublishDir>
+    <PublishProtocol>FileSystem</PublishProtocol>
+    <_TargetId>Folder</_TargetId>
+  </PropertyGroup>
+</Project>

NoSugarNet.ClientCore.Standard2/Properties/PublishProfiles/FolderProfile.pubxml.user

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+https://go.microsoft.com/fwlink/?LinkID=208121.
+-->
+<Project>
+  <PropertyGroup>
+    <History>True|2024-04-15T06:51:39.2435225Z;True|2024-04-15T14:51:19.4250865+08:00;True|2024-04-15T14:49:22.9829361+08:00;</History>
+    <LastFailureDetails />
+  </PropertyGroup>
+</Project>

NoSugarNet.ClientCore/AppNoSugarNet.cs

@@ -26,7 +26,7 @@ namespace NoSugarNet.ClientCore
         public static event OnUpdateStatusHandler OnUpdateStatus;
         #endregion
 
-        public static void Init(string IP, int port, OnLogHandler onLog = null)
+        public static void Init(OnLogHandler onLog = null)
         {
             log = new LogManager();
             if(onLog != null)
@@ -37,14 +37,26 @@ namespace NoSugarNet.ClientCore
             local = new AppLocalClient();
             user = new UserDataManager();
             netStatus = new NetStatus();
+            _SpeedCheckTimeTimer = new System.Timers.Timer();
+            _SpeedCheckTimeTimer.Interval = TimerInterval;
+            _SpeedCheckTimeTimer.Elapsed += Checktimer_Elapsed;
+            _SpeedCheckTimeTimer.AutoReset = true;
+        }
+
+        public static void Connect(string IP, int port)
+        {
             if (networkHelper.Init(IP, port))
-			{
-				_SpeedCheckTimeTimer = new System.Timers.Timer();
-				_SpeedCheckTimeTimer.Interval = TimerInterval;
-				_SpeedCheckTimeTimer.Elapsed += Checktimer_Elapsed;
-				_SpeedCheckTimeTimer.AutoReset = true;
-				_SpeedCheckTimeTimer.Enabled = true;
-			}
+                _SpeedCheckTimeTimer.Enabled = true;
+            else
+                _SpeedCheckTimeTimer.Enabled = false;
+        }
+
+        public static void Close()
+        {
+            local.StopAll();
+            networkHelper.CloseConntect();
+            AppNoSugarNet.log.Info("停止");
+            _SpeedCheckTimeTimer.Enabled = false;
         }
 
         static void Checktimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
@@ -66,7 +78,6 @@ namespace NoSugarNet.ClientCore
                 tReciveSecSpeed = (local.tReciveAllLenght - netStatus.tReciveAllLenght) / (TimerInterval / 1000),
             };
             netStatus = resutnetStatus;
-
             OnUpdateStatus?.Invoke(resutnetStatus);
         }
     }

NoSugarNet.ClientCore/Manager/AppLocalClient.cs

@@ -54,13 +54,13 @@ namespace ServerCore.Manager
         /// </summary>
         void InitListenerMode()
         {
-            AppNoSugarNet.log.Debug("初始化压缩适配器" + compressAdapterType);
+            AppNoSugarNet.log.Info("初始化压缩适配器" + compressAdapterType);
             //初始化压缩适配器，代表压缩类型
             mCompressAdapter = new CompressAdapter(compressAdapterType);
             foreach (var cfg in mDictTunnelID2Cfg)
             {
                 LocalListener listener = new LocalListener(256, 1024, cfg.Key);
-                AppNoSugarNet.log.Debug($"开始监听配置 Tunnel:{cfg.Key},Port:{cfg.Value.Port}");
+                AppNoSugarNet.log.Info($"开始监听配置 Tunnel:{cfg.Key},Port:{cfg.Value.Port}");
                 listener.Init();
                 listener.Start(new IPEndPoint(IPAddress.Any.Address, (int)cfg.Value.Port));
                 //listener.Init((int)cfg.Value.Port);
@@ -249,7 +249,7 @@ namespace ServerCore.Manager
         /// <param name="data"></param>
         public void OnServerLocalDataCallBack(byte tunnelId,byte Idx, byte[] data)
         {
-            //AppNoSugarNet.log.Debug($"OnServerLocalDataCallBack {tunnelId},{Idx},Data长度：{data.Length}");
+            //AppNoSugarNet.log.Info($"OnServerLocalDataCallBack {tunnelId},{Idx},Data长度：{data.Length}");
             if (!GetLocalListener(tunnelId, out LocalListener _listener))
                 return;
             //记录压缩前数据长度
@@ -266,7 +266,7 @@ namespace ServerCore.Manager
         /// <param name="data"></param>
         public void OnClientTunnelDataCallBack(byte tunnelId,byte Idx, byte[] data)
         {
-            //AppNoSugarNet.log.Debug($"OnClientTunnelDataCallBack {tunnelId},{Idx}");
+            //AppNoSugarNet.log.Info($"OnClientTunnelDataCallBack {tunnelId},{Idx}");
 
             int SlienLenght = 1000;
             //判断数据量大时分包

NoSugarNet.ClientCore/Manager/AppLogin.cs

@@ -25,12 +25,12 @@ namespace NoSugarNet.ClientCore.Manager
             Protobuf_Login_RESP msg = ProtoBufHelper.DeSerizlize<Protobuf_Login_RESP>(reqData);
             if (msg.Status == LoginResultStatus.Ok)
             {
-                AppNoSugarNet.log.Debug("登录成功");
+                AppNoSugarNet.log.Info("登录成功");
                 AppNoSugarNet.user.InitMainUserData(AppNoSugarNet.user.userdata.Account);
             }
             else
             {
-                AppNoSugarNet.log.Debug("登录失败");
+                AppNoSugarNet.log.Info("登录失败");
             }
         }
 

NoSugarNet.ClientCore/Manager/LocalClient/LocalListener.cs

@@ -21,7 +21,7 @@ namespace NoSugarNet.ClientCore
 
         private void ClientNumberChange(int num, AsyncUserToken token)
         {
-            AppNoSugarNet.log.Debug("Client数发生变化");
+            AppNoSugarNet.log.Info("Client数发生变化");
             //增加连接数
             if (num > 0)
             {
@@ -61,7 +61,7 @@ namespace NoSugarNet.ClientCore
 
         public void DataCallBack(Socket sk, byte[] data)
         {
-            //AppNoSugarNet.log.Debug("收到消息 数据长度=>" + data.Length);
+            //AppNoSugarNet.log.Info("收到消息 数据长度=>" + data.Length);
             //记录接受长度
             mReciveAllLenght += data.Length;
             if (!GetSocketIdxBySocket(sk, out int Idx))
@@ -73,7 +73,7 @@ namespace NoSugarNet.ClientCore
             }
             catch (Exception ex)
             {
-                AppNoSugarNet.log.Debug("逻辑处理错误：" + ex.ToString());
+                AppNoSugarNet.log.Info("逻辑处理错误：" + ex.ToString());
             }
         }
 
@@ -91,7 +91,7 @@ namespace NoSugarNet.ClientCore
         /// <param name="sk"></param>
         public void OnDisconnect(AsyncUserToken token)
         {
-            AppNoSugarNet.log.Debug("断开连接");
+            AppNoSugarNet.log.Info("断开连接");
 
             if (!GetSocketIdxBySocket(token.Socket, out int Idx))
                 return;
@@ -102,7 +102,7 @@ namespace NoSugarNet.ClientCore
 
         public void OnShowNetLog(string msg)
         {
-            AppNoSugarNet.log.Debug(msg);
+            AppNoSugarNet.log.Info(msg);
         }
 
         #region 一个轻量级无用户连接管理
@@ -205,9 +205,9 @@ namespace NoSugarNet.ClientCore
             if (!GetSocketByIdx(Idx, out LocalClientInfo _localClientInfo))
                 return;
             if (bConnected)
-                AppNoSugarNet.log.Debug("远端本地连接已连接！！！！");
+                AppNoSugarNet.log.Info("远端本地连接已连接！！！！");
             else
-                AppNoSugarNet.log.Debug("远端本地连接已断开连接！！！！");
+                AppNoSugarNet.log.Info("远端本地连接已断开连接！！！！");
             _localClientInfo.bRemoteConnect = bConnected;
         }
 

NoSugarNet.ClientCore/Manager/LocalClient/LocalListener_Source.cs

@@ -22,7 +22,7 @@ namespace NoSugarNet.ClientCore
 
         private void ClientNumberChange(Socket socket)
         {
-            AppNoSugarNet.log.Debug("Client数发生变化");
+            AppNoSugarNet.log.Info("Client数发生变化");
             //增加连接数
             int Idx = AddDictSocket(socket);
             if (GetSocketByIdx(Idx, out LocalClientInfo _localClientInf))
@@ -59,7 +59,7 @@ namespace NoSugarNet.ClientCore
 
         public void DataCallBack(Socket sk, byte[] data)
         {
-            //AppNoSugarNet.log.Debug("收到消息 数据长度=>" + data.Length);
+            //AppNoSugarNet.log.Info("收到消息 数据长度=>" + data.Length);
             //记录接受长度
             mReciveAllLenght += data.Length;
             if (!GetSocketIdxBySocket(sk, out int Idx))
@@ -83,7 +83,7 @@ namespace NoSugarNet.ClientCore
             }
             catch (Exception ex)
             {
-                AppNoSugarNet.log.Debug("逻辑处理错误：" + ex.ToString());
+                AppNoSugarNet.log.Info("逻辑处理错误：" + ex.ToString());
             }
         }
 
@@ -101,7 +101,7 @@ namespace NoSugarNet.ClientCore
         /// <param name="sk"></param>
         public void OnDisconnectClient(Socket sk)
         {
-            AppNoSugarNet.log.Debug("断开连接");
+            AppNoSugarNet.log.Info("断开连接");
 
             if (!GetSocketIdxBySocket(sk, out int Idx))
                 return;
@@ -112,7 +112,7 @@ namespace NoSugarNet.ClientCore
 
         public void OnShowNetLog(string msg)
         {
-            AppNoSugarNet.log.Debug(msg);
+            AppNoSugarNet.log.Info(msg);
         }
 
         #region 一个轻量级无用户连接管理
@@ -233,9 +233,9 @@ namespace NoSugarNet.ClientCore
             if (!GetSocketByIdx(Idx, out LocalClientInfo _localClientInfo))
                 return;
             if (bConnected)
-                AppNoSugarNet.log.Debug("远端本地连接已连接！！！！");
+                AppNoSugarNet.log.Info("远端本地连接已连接！！！！");
             else
-                AppNoSugarNet.log.Debug("远端本地连接已断开连接！！！！");
+                AppNoSugarNet.log.Info("远端本地连接已断开连接！！！！");
             _localClientInfo.bRemoteConnect = bConnected;
         }
 

NoSugarNet.ClientCore/Manager/LocalClient/LocalMsgQueuePool.cs

@@ -1,4 +1,4 @@
-namespace HaoYueNet.ServerNetwork
+namespace NoSugarNet.ClientCore
 {
     public class IdxWithMsg
     {

NoSugarNet.ClientCore/Manager/LogManager.cs

@@ -2,6 +2,13 @@
 {
     public class LogManager
     {
+        public enum E_LogType:byte
+        {
+            Info = 0,
+            Debug = 1,
+            Warning = 2,
+            Error = 3,
+        }
         /// <summary>
         /// 日志
         /// </summary>
@@ -13,19 +20,29 @@
         /// </summary>
         public static event OnLogHandler OnLog;
 
+        public void Info(string str)
+        {
+            Log(E_LogType.Info, str);
+        }
+
         public void Debug(string str)
         {
-            OnLog?.Invoke(0,str);
+            Log(E_LogType.Debug, str);
         }
 
         public void Warning(string str)
         {
-            OnLog?.Invoke(1,str);
+            Log(E_LogType.Warning, str);
         }
 
         public void Error(string str)
         {
-            OnLog?.Invoke(2,str);
+            Log(E_LogType.Error, str);
+        }
+
+        public void Log(E_LogType logtype,string str)
+        {
+            OnLog?.Invoke((int)logtype, str);
         }
     }
 }

NoSugarNet.ClientCore/Network/NetworkHelper.cs

@@ -60,7 +60,7 @@ namespace NoSugarNet.ClientCore.Network
         {
             //用于Unity内的输出
             //Debug.Log("NetCoreDebug >> "+str);
-            AppNoSugarNet.log.Debug("NetCoreDebug >> " + str);
+            AppNoSugarNet.log.Info("NetCoreDebug >> " + str);
         }
 
         /// <summary>
@@ -114,13 +114,13 @@ namespace NoSugarNet.ClientCore.Network
             {
                 //等待时间
                 Thread.Sleep(ReConnectTryTime);
-                AppNoSugarNet.log.Debug($"尝试自动重连{LastConnectIP}:{LastConnectPort}……");
+                AppNoSugarNet.log.Info($"尝试自动重连{LastConnectIP}:{LastConnectPort}……");
                 //第一步
                 if (Init(LastConnectIP, LastConnectPort))
                 {
-                    AppNoSugarNet.log.Debug($"自动重连成功!");
+                    AppNoSugarNet.log.Info($"自动重连成功!");
                     bflagDone = true;
-                    AppNoSugarNet.log.Debug($"触发重连后的自动逻辑!");
+                    AppNoSugarNet.log.Info($"触发重连后的自动逻辑!");
                     OnReConnected?.Invoke();
                 }
             } while (!bflagDone);

NoSugarNet.ClientCore/NoSugarNet.ClientCore.csproj

@@ -4,11 +4,7 @@
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-  </PropertyGroup>  
-
-  <ItemGroup>
-    <ProjectReference Include="..\NoSugarNet.DataHelper\NoSugarNet.DataHelper.csproj" />
-  </ItemGroup>
+  </PropertyGroup>
 
   <ItemGroup>
     <Reference Include="Google.Protobuf">
@@ -20,6 +16,9 @@
     <Reference Include="HaoYueNet.ServerNetwork">
       <HintPath>..\Lib\HaoYueNet.ServerNetwork.dll</HintPath>
     </Reference>
+    <Reference Include="NoSugarNet.DataHelper">
+      <HintPath>..\Lib\NoSugarNet.DataHelper.dll</HintPath>
+    </Reference>
   </ItemGroup>
 
 </Project>

NoSugarNet.DataHelper/Common/CompressAdapter.cs

@@ -1,4 +1,5 @@
-using System.IO.Compression;
+using System.IO;
+using System.IO.Compression;
 
 namespace NoSugarNet.DataHelper
 {
@@ -49,8 +50,8 @@ namespace NoSugarNet.DataHelper
 
     public interface IDataCompress
     {
-        public byte[] Compress(byte[] data);
-        public byte[] Decompress(byte[] data);
+        byte[] Compress(byte[] data);
+        byte[] Decompress(byte[] data);
     }
 
     public class NoCompress : IDataCompress

NoSugarNet.DataHelper/NoSugarNet.DataHelper.csproj

@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
+    <TargetFramework>netstandard2.0</TargetFramework>
   </PropertyGroup>
-
-</Project>
+  <PropertyGroup>
+	<!--避免 错误	CS8630	无效的 nullable 值: C# 7.3 的“Enable”。请使用语言版本 8.0 或更高版本 -->
+   <LangVersion>8.0</LangVersion>
+  </PropertyGroup>
+</Project>

NoSugarNet.DataHelper/NoSugarNet.DataHelper.csproj.user

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <_LastSelectedProfileId>F:\Sin365\NoSugarNet\NoSugarNet.DataHelper\Properties\PublishProfiles\FolderProfile.pubxml</_LastSelectedProfileId>
+  </PropertyGroup>
+</Project>

NoSugarNet.sln

@@ -22,16 +22,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NoSugarNet.ServerCli", "Sam
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NoSugarNet.DataHelper", "NoSugarNet.DataHelper\NoSugarNet.DataHelper.csproj", "{3C41B685-B46B-4057-826B-C8C6F395BFA8}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Net4X", "Net4X", "{4A660CAE-CD92-411C-9D8E-7CB677DB3C74}"
-	ProjectSection(SolutionItems) = preProject
-		Lib\Net4x\HaoYueNet.ClientNetworkNet4x.dll = Lib\Net4x\HaoYueNet.ClientNetworkNet4x.dll
-		Lib\Net4x\HaoYueNet.ServerNetworkNet4x.dll = Lib\Net4x\HaoYueNet.ServerNetworkNet4x.dll
-		Lib\Net4x\System.Buffers.dll = Lib\Net4x\System.Buffers.dll
-		Lib\Net4x\System.Memory.dll = Lib\Net4x\System.Memory.dll
-		Lib\Net4x\System.Runtime.CompilerServices.Unsafe.dll = Lib\Net4x\System.Runtime.CompilerServices.Unsafe.dll
-	EndProjectSection
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "NetLib_Standard2", "NetLib_Standard2", "{4A660CAE-CD92-411C-9D8E-7CB677DB3C74}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NoSugarNet.ClientCoreNet4x", "NoSugarNet.ClientCoreNet4x\NoSugarNet.ClientCoreNet4x.csproj", "{F565C3B8-E210-45F5-9B9E-8C1A49438753}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NoSugarNet.ClientCore.Standard2", "NoSugarNet.ClientCore.Standard2\NoSugarNet.ClientCore.Standard2.csproj", "{5DB2B608-6F99-430A-99AC-534410393955}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -59,10 +52,10 @@ Global
 		{3C41B685-B46B-4057-826B-C8C6F395BFA8}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{3C41B685-B46B-4057-826B-C8C6F395BFA8}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3C41B685-B46B-4057-826B-C8C6F395BFA8}.Release|Any CPU.Build.0 = Release|Any CPU
-		{F565C3B8-E210-45F5-9B9E-8C1A49438753}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F565C3B8-E210-45F5-9B9E-8C1A49438753}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{F565C3B8-E210-45F5-9B9E-8C1A49438753}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{F565C3B8-E210-45F5-9B9E-8C1A49438753}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5DB2B608-6F99-430A-99AC-534410393955}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5DB2B608-6F99-430A-99AC-534410393955}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5DB2B608-6F99-430A-99AC-534410393955}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5DB2B608-6F99-430A-99AC-534410393955}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

NosugarNetForUnity/Assets/MainUI.cs

@@ -1,4 +1,4 @@
-using NoSugarNet.ClientCoreNet4x;
+using NoSugarNet.ClientCoreNet.Standard2;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -9,16 +9,32 @@ public class MainUI : MonoBehaviour
 {
 
     public Button btnStart;
+    public Button btnStop;
     public InputField inputIP;
     public InputField inputPort;
-    public Text textLog;
 
     // Start is called before the first frame update
     void Start()
     {
+
+        string LastIP =  PlayerPrefs.GetString("LastIP");
+        string LastPort = PlayerPrefs.GetString("LastPort");
+        if(!string.IsNullOrEmpty(LastIP))
+            inputIP.text = LastIP;
+        if (!string.IsNullOrEmpty(LastPort))
+            inputPort.text = LastPort;
+
         btnStart.onClick.AddListener(InitNoSugarNetClient);
-        textLog.text = "-";
-        AddLog("123");
+        btnStop.onClick.AddListener(StopNoSugarNetClient);
+        AddLog("");
+
+        AppNoSugarNet.OnUpdateStatus += OnUpdateStatus;
+        AppNoSugarNet.Init(OnNoSugarNetLog);
+    }
+
+    private void OnDisable()
+    {
+        AppNoSugarNet.Close();
     }
 
     // Update is called once per frame
@@ -34,8 +50,14 @@ public class MainUI : MonoBehaviour
             OnNoSugarNetLog(0,"配置错误");
             return;
         }
-        AppNoSugarNet.OnUpdateStatus += OnUpdateStatus;
-        AppNoSugarNet.Init(inputIP.text, Convert.ToInt32(inputPort.text), OnNoSugarNetLog);
+
+        PlayerPrefs.SetString("LastIP", inputIP.text);
+        PlayerPrefs.GetString("LastPort",inputPort.text);
+        AppNoSugarNet.Connect(inputIP.text, Convert.ToInt32(inputPort.text));
+    }
+    void StopNoSugarNetClient()
+    {
+        AppNoSugarNet.Close();
     }
 
 
@@ -63,7 +85,10 @@ public class MainUI : MonoBehaviour
 
         // 设置字体大小
         style.fontSize = 24;
-        GUI.TextField(new Rect(10, 300, Screen.width - 20, 1000), logText, style);
+        style.fontStyle = FontStyle.Bold;
+        style.normal.textColor = Color.white;
+
+        GUI.TextField(new Rect(10, 400, Screen.width - 20, 1520), logText, style);
     }
 
     static void AddLog(string msg)
@@ -72,7 +97,7 @@ public class MainUI : MonoBehaviour
         logText += string.Format("{0}\n", System.DateTime.Now.ToString("HH:mm:ss> ") + msg);
 
         // 限制文本框显示的最大行数
-        if (logText.Split('\n').Length > 50)
+        if (logText.Split('\n').Length > 80)
         {
             string[] lines = logText.Split('\n');
             logText = "";

NosugarNetForUnity/Assets/MainUI.prefab

@@ -33,12 +33,12 @@ RectTransform:
   - {fileID: 4996346368674553336}
   - {fileID: 4996346368210045502}
   m_Father: {fileID: 4996346368486089535}
-  m_RootOrder: 2
+  m_RootOrder: 1
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0.5, y: 0.5}
-  m_AnchorMax: {x: 0.5, y: 0.5}
-  m_AnchoredPosition: {x: -262.22324, y: 820.0001}
-  m_SizeDelta: {x: 524.4465, y: 156.28}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: 282.9455, y: -113.47998}
+  m_SizeDelta: {x: 534.784, y: 103.25}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!222 &4996346366834629249
 CanvasRenderer:
@@ -138,7 +138,7 @@ MonoBehaviour:
   m_CaretColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1}
   m_CustomCaretColor: 0
   m_SelectionColor: {r: 0.65882355, g: 0.80784315, b: 1, a: 0.7529412}
-  m_Text: 127.0.0.1
+  m_Text: 139.186.160.243
   m_CaretBlinkRate: 0.85
   m_CaretWidth: 1
   m_ReadOnly: 0
@@ -254,12 +254,12 @@ RectTransform:
   m_Children:
   - {fileID: 4996346367104132246}
   m_Father: {fileID: 4996346368486089535}
-  m_RootOrder: 1
+  m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0.5, y: 0.5}
-  m_AnchorMax: {x: 0.5, y: 0.5}
-  m_AnchoredPosition: {x: 409.68347, y: 820}
-  m_SizeDelta: {x: 238.7751, y: 156.2808}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: 816.7334, y: -113.47998}
+  m_SizeDelta: {x: 174.8618, y: 103.2501}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!222 &4996346367916384534
 CanvasRenderer:
@@ -376,12 +376,12 @@ RectTransform:
   - {fileID: 4996346368504347606}
   - {fileID: 4996346368893432072}
   m_Father: {fileID: 4996346368486089535}
-  m_RootOrder: 3
+  m_RootOrder: 2
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0.5, y: 0.5}
-  m_AnchorMax: {x: 0.5, y: 0.5}
-  m_AnchoredPosition: {x: 146.883, y: 820.0001}
-  m_SizeDelta: {x: 261.3027, y: 156.28}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: 639.8202, y: -113.47998}
+  m_SizeDelta: {x: 178.9625, y: 103.25}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!222 &4996346368177541231
 CanvasRenderer:
@@ -481,7 +481,7 @@ MonoBehaviour:
   m_CaretColor: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1}
   m_CustomCaretColor: 0
   m_SelectionColor: {r: 0.65882355, g: 0.80784315, b: 1, a: 0.7529412}
-  m_Text: 10001
+  m_Text: 1000
   m_CaretBlinkRate: 0.85
   m_CaretWidth: 1
   m_ReadOnly: 0
@@ -564,103 +564,7 @@ MonoBehaviour:
     m_HorizontalOverflow: 1
     m_VerticalOverflow: 0
     m_LineSpacing: 1
-  m_Text: 127.0.0.1
---- !u!1 &4996346368454841980
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 4996346368454841971}
-  - component: {fileID: 4996346368454841969}
-  - component: {fileID: 4996346368454841970}
-  m_Layer: 5
-  m_Name: log
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!224 &4996346368454841971
-RectTransform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 4996346368454841980}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0, y: 0, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
-  m_Father: {fileID: 4996346368486089535}
-  m_RootOrder: 0
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0, y: 0}
-  m_AnchorMax: {x: 1, y: 1}
-  m_AnchoredPosition: {x: 0, y: -136.23236}
-  m_SizeDelta: {x: 0, y: -272.4646}
-  m_Pivot: {x: 0.5, y: 0.5}
---- !u!222 &4996346368454841969
-CanvasRenderer:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 4996346368454841980}
-  m_CullTransparentMesh: 1
---- !u!114 &4996346368454841970
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 4996346368454841980}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
-  m_Material: {fileID: 0}
-  m_Color: {r: 1, g: 1, b: 1, a: 1}
-  m_RaycastTarget: 1
-  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
-  m_Maskable: 1
-  m_OnCullStateChanged:
-    m_PersistentCalls:
-      m_Calls: []
-  m_FontData:
-    m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0}
-    m_FontSize: 64
-    m_FontStyle: 0
-    m_BestFit: 0
-    m_MinSize: 10
-    m_MaxSize: 168
-    m_Alignment: 0
-    m_AlignByGeometry: 0
-    m_RichText: 1
-    m_HorizontalOverflow: 0
-    m_VerticalOverflow: 0
-    m_LineSpacing: 1
-  m_Text: 'New Text
-
-    New Text
-
-    New Text
-
-    New Text
-
-    New TextNew Text
-
-    New
-    Text
-
-    New Text
-
-    New Text
-
-    New Text'
+  m_Text: 139.186.160.243
 --- !u!1 &4996346368486089528
 GameObject:
   m_ObjectHideFlags: 0
@@ -691,10 +595,10 @@ RectTransform:
   m_LocalPosition: {x: 0, y: 0, z: 0}
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children:
-  - {fileID: 4996346368454841971}
   - {fileID: 4996346367916384529}
   - {fileID: 4996346366834629260}
   - {fileID: 4996346368177541226}
+  - {fileID: 7539436960902585095}
   m_Father: {fileID: 0}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
@@ -724,7 +628,7 @@ MonoBehaviour:
   m_Name: 
   m_EditorClassIdentifier: 
   m_Material: {fileID: 0}
-  m_Color: {r: 0, g: 0, b: 0, a: 0.6745098}
+  m_Color: {r: 0, g: 0, b: 0, a: 1}
   m_RaycastTarget: 1
   m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
   m_Maskable: 1
@@ -754,9 +658,9 @@ MonoBehaviour:
   m_Name: 
   m_EditorClassIdentifier: 
   btnStart: {fileID: 4996346367916384528}
+  btnStop: {fileID: 8117411947949469824}
   inputIP: {fileID: 4996346366834629251}
   inputPort: {fileID: 4996346368177541225}
-  textLog: {fileID: 4996346368454841970}
 --- !u!1 &4996346368504347607
 GameObject:
   m_ObjectHideFlags: 0
@@ -993,4 +897,204 @@ MonoBehaviour:
     m_HorizontalOverflow: 1
     m_VerticalOverflow: 0
     m_LineSpacing: 1
-  m_Text: 10001
+  m_Text: 1000
+--- !u!1 &6186141588528339253
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 7539436960902585095}
+  - component: {fileID: 8969929348320387260}
+  - component: {fileID: 5841535602750926888}
+  - component: {fileID: 8117411947949469824}
+  m_Layer: 5
+  m_Name: btnStop
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &7539436960902585095
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6186141588528339253}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 5278454553715044843}
+  m_Father: {fileID: 4996346368486089535}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: 993.73157, y: -113.47998}
+  m_SizeDelta: {x: 172.537, y: 103.2501}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &8969929348320387260
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6186141588528339253}
+  m_CullTransparentMesh: 1
+--- !u!114 &5841535602750926888
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6186141588528339253}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!114 &8117411947949469824
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6186141588528339253}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Navigation:
+    m_Mode: 3
+    m_WrapAround: 0
+    m_SelectOnUp: {fileID: 0}
+    m_SelectOnDown: {fileID: 0}
+    m_SelectOnLeft: {fileID: 0}
+    m_SelectOnRight: {fileID: 0}
+  m_Transition: 1
+  m_Colors:
+    m_NormalColor: {r: 1, g: 1, b: 1, a: 1}
+    m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1}
+    m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608}
+    m_ColorMultiplier: 1
+    m_FadeDuration: 0.1
+  m_SpriteState:
+    m_HighlightedSprite: {fileID: 0}
+    m_PressedSprite: {fileID: 0}
+    m_SelectedSprite: {fileID: 0}
+    m_DisabledSprite: {fileID: 0}
+  m_AnimationTriggers:
+    m_NormalTrigger: Normal
+    m_HighlightedTrigger: Highlighted
+    m_PressedTrigger: Pressed
+    m_SelectedTrigger: Selected
+    m_DisabledTrigger: Disabled
+  m_Interactable: 1
+  m_TargetGraphic: {fileID: 5841535602750926888}
+  m_OnClick:
+    m_PersistentCalls:
+      m_Calls: []
+--- !u!1 &9128063835190157119
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 5278454553715044843}
+  - component: {fileID: 2931565232197910918}
+  - component: {fileID: 2465264613758728606}
+  m_Layer: 5
+  m_Name: Text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &5278454553715044843
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 9128063835190157119}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 7539436960902585095}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!222 &2931565232197910918
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 9128063835190157119}
+  m_CullTransparentMesh: 1
+--- !u!114 &2465264613758728606
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 9128063835190157119}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0}
+    m_FontSize: 84
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 10
+    m_MaxSize: 92
+    m_Alignment: 4
+    m_AlignByGeometry: 0
+    m_RichText: 1
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: "\u505C\u6B62"

NosugarNetForUnity/Assets/Plugins/HaoYueNet.ClientNetworkNet.Standard2.dll.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 368515f1ed1e54a42b6a8dfb547ca20c
+guid: 324deac494a24a7499801349c7908062
 PluginImporter:
   externalObjects: {}
   serializedVersion: 2

NosugarNetForUnity/Assets/Plugins/HaoYueNet.ServerNetwork.Standard2.dll.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 1f9384be4094cf448a9f7458308f9af9
+guid: bba3137572a9a52478aa945ce387a192
 PluginImporter:
   externalObjects: {}
   serializedVersion: 2

NosugarNetForUnity/Assets/Plugins/NoSugarNet.ClientCore.Standard2.dll.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 3d415ce2c5ebcd641b5c9b76fc5a7da8
+guid: 208c5b5b9ca9139418ec61b89a1516ed
 PluginImporter:
   externalObjects: {}
   serializedVersion: 2

NosugarNetForUnity/Assets/Plugins/NoSugarNet.DataHelper.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 1d83e3c67ee8b794c97b5876ece7a16e
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

NosugarNetForUnity/Assets/Plugins/System.Numerics.Vectors.dll.meta

@@ -0,0 +1,33 @@
+fileFormatVersion: 2
+guid: 677f64bf577a1724699f45841c5bcb04
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

NosugarNetForUnity/Assets/Scenes/SampleScene.unity

@@ -477,6 +477,22 @@ PrefabInstance:
   m_Modification:
     m_TransformParent: {fileID: 1414424416}
     m_Modifications:
+    - target: {fileID: 4996346366834629251, guid: 1706084c5d625e2459ee1aaebb264e40, type: 3}
+      propertyPath: m_Text
+      value: 127.0.0.1
+      objectReference: {fileID: 0}
+    - target: {fileID: 4996346368454841970, guid: 1706084c5d625e2459ee1aaebb264e40, type: 3}
+      propertyPath: m_Color.b
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4996346368454841970, guid: 1706084c5d625e2459ee1aaebb264e40, type: 3}
+      propertyPath: m_Color.g
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4996346368454841970, guid: 1706084c5d625e2459ee1aaebb264e40, type: 3}
+      propertyPath: m_Color.r
+      value: 0
+      objectReference: {fileID: 0}
     - target: {fileID: 4996346368486089528, guid: 1706084c5d625e2459ee1aaebb264e40, type: 3}
       propertyPath: m_Name
       value: MainUI

Sample/NoSugarNet.ClientCli/Program.cs

@@ -14,10 +14,25 @@ namespace NoSugarNet.ClientCli
                 return;
             }
             AppNoSugarNet.OnUpdateStatus += OnUpdateStatus;
-            AppNoSugarNet.Init(Config.ServerIP, Config.ServerPort, OnNoSugarNetLog);
+            AppNoSugarNet.Init(OnNoSugarNetLog);
+            AppNoSugarNet.Connect(Config.ServerIP, Config.ServerPort);
             while (true)
             {
-                Console.ReadLine();
+                string CommandStr = Console.ReadLine();
+                string Command = "";
+                Command = ((CommandStr.IndexOf(" ") <= 0) ? CommandStr : CommandStr.Substring(0, CommandStr.IndexOf(" ")));
+                string[] CmdArr = CommandStr.Split(' ');
+                switch (Command)
+                {
+                    case "con":
+                        AppNoSugarNet.Connect(Config.ServerIP, Config.ServerPort);
+                        break;
+                    case "stop":
+                        AppNoSugarNet.Close();
+                        break;
+                    default:
+                        break;
+                }
             }
         }
         static void OnUpdateStatus(NetStatus netState)