网络游戏客户端通信模块简单实现

网络游戏客户端通信模块的简单实现如下，未经充分测试，功能也不完善，纯实学习，积累之用。

1. 首先是发送的包的封装，与服务端约定好的协议，代码如下：

using Cmd;
using ProtoBuf.Meta;
using System;
using System.Collections.Generic;
using System.IO;

namespace Network
{
    /// <summary>
    /// 发送的包，包体结构如下：
    /// 1. 包体长度（4字节）
    /// 2. 签名（4字节）
    /// 3. protoId（2字节）
    /// 4. 序列id（4字节）
    /// 5. 包体
    /// </summary>
    public class SendingPacket
    {
        static uint s_lastSequenceId;                       // 上一次的序列id

        uint m_length;                                      // 包长度（4字节）
        uint m_sign;                                        // 签名（4字节）
        ushort m_protoId;                                   // protoId（2字节）
        uint m_sequenceId;                                  // 序列id（4字节）
        MemoryStream m_body = new MemoryStream();           // 包体

        // Properties
        public Action<ReturnPacket> OnPacketReturn { get; set; }
        public EProtoId? ExpectedReturnId { get; set; }
        public bool SendWait { get; set; }
        public EProtoId ProtoId { get { return (EProtoId)m_protoId; } }

        #region static

        // 序列id会不断自增
        static uint GetSequenceId()
        {
            return ++s_lastSequenceId;
        }

        // 计算签名
        static uint CalcSign(byte[] bytes)
        {
            if (bytes == null)
                throw new ArgumentNullException("bytes");

            const string str = "45ddk124k55k3l9djdssk9gk1zc6bn9cpo4afcx4322121ddafadfasdfazctewq";
            uint[] tempArray = new uint[256];

            for (int i = 0; i < tempArray.Length; i++)
            {
                if (i < str.Length)
                    tempArray[i] = str[i];
            }

            int clampI = 0;
            uint sign = 0;

            for (int i = 0; i < tempArray.Length; i++)
            {
                if (clampI >= bytes.Length)
                    clampI %= bytes.Length;

                byte b = bytes[clampI];
                uint r = 0;

                switch ((clampI + i) % 4)
                {
                    case 0:
                        r = (uint)(b | tempArray[i]);
                        break;
                    case 1:
                        r = (uint)(b + tempArray[i]);
                        break;
                    case 2:
                        r = (uint)(b * 2);
                        break;
                    case 3:
                        r = (uint)(b > tempArray[i] ? (b - tempArray[i]) : (tempArray[i] - b));
                        break;
                    default:
                        throw new InvalidOperationException("Unexpected result: " + ((clampI + i) % 4));
                }
                r %= 128;

                sign += r;

                clampI += (int)tempArray[i];
            }

            return sign % 1024;
        }

        #endregion

        public SendingPacket(EProtoId protoId, object body)
        {
            if (body == null)
                throw new ArgumentNullException("body");

            m_protoId = (ushort)protoId;

            // 序列化
            RuntimeTypeModel.Default.Serialize(m_body, body);

            // length
            m_length = (uint)(m_body.Length + 4 + 4 + 2);
            m_length |= 0x20000000;                 // 与服务端的约定，最高位为1，此时服务端会验证签名
        }

        /// <summary>
        /// 每次发包都需要更新序列id和签名
        /// </summary>
        public void UpdateSequenceId()
        {
            m_sequenceId = GetSequenceId();

            // sign
            var forSign = new List<byte>();
            {
                forSign.AddRange(BitConverter.GetBytes(m_protoId));
                forSign.AddRange(BitConverter.GetBytes(m_sequenceId));
                forSign.AddRange(m_body.ToArray());
            }
            m_sign = CalcSign(forSign.ToArray());
        }

        public byte[] GetBytes()
        {
            var list = new List<byte>();
            {
                list.AddRange(BitConverter.GetBytes(m_length));
                list.AddRange(BitConverter.GetBytes(m_sign));
                list.AddRange(BitConverter.GetBytes(m_protoId));
                list.AddRange(BitConverter.GetBytes(m_sequenceId));
                list.AddRange(m_body.ToArray());
            }

            return list.ToArray();
        }
    }
}

2. 收到的包的封装，代码如下：

using Cmd;
using System;

namespace Network
{
    /// <summary>
    /// 接收到的包，结构如下：
    /// 1. 包体长度（4字节）
    /// 2. protoId（2字节）
    /// 3. 包体
    /// </summary>
    public class ReturnPacket
    {
        ushort m_protoId;
        byte[] m_body;

        // Properties
        public EProtoId ProtoId { get { return (EProtoId)m_protoId; } }
        public byte[] Body { get { return m_body; } }

        public ReturnPacket(ushort protoId, byte[] body)
        {
            if (body == null)
                throw new ArgumentNullException("body");

            m_protoId = protoId;
            m_body = body;
        }
    }
}

3. 解包工具，代码如下：

using System;
using UnityEngine;

namespace Network
{
    /// <summary>
    /// 解包工具
    /// </summary>
    class UnpackTool
    {
        const int HeadLength = 6;

        byte[] m_readBuffer = new byte[256 * 1024];
        int m_beginOffset = 0;
        int m_endOffset = 0;

        public void Reset()
        {
            m_beginOffset = 0;
            m_endOffset = 0;
        }

        public void UnpackData(byte[] receivedBuffer, int receivedLength, Action<ReturnPacket> unpackCallback)
        {
            if (receivedLength <= 0)
                return;

            Array.Copy(receivedBuffer, 0, m_readBuffer, m_endOffset, receivedLength);
            m_endOffset += receivedLength;

            while (m_endOffset - m_beginOffset >= HeadLength)
            {
                int bodyLen = BitConverter.ToInt32(m_readBuffer, m_beginOffset) - 2;
                int packetLen = bodyLen + 4 + 2;

                if (m_endOffset - m_beginOffset < packetLen)
                {
                    Debug.LogError(string.Format("Data not enought, bodyLen={0}, m_beginOffset={1}, m_endOffset={2}", bodyLen, m_beginOffset, m_endOffset));
                    break;
                }

                UInt16 protoId = BitConverter.ToUInt16(m_readBuffer, m_beginOffset + 4);
                if (protoId == 256)//特殊处理，这个包如果id是256，那其实是服务端对于我发给他的心跳包的原样返回，由于小根转换的原因会反一反，其实真实id是1，256这个数后端说是不会主动发过来的。
                {
                    // [dev] ??? 16位的数最大值为255，怎么可能到256，逗我？
                    Debug.LogError("protoId is: " + protoId);
                    protoId = 1;
                }

                //Debug.Log("protoId:0x" + Convert.ToString(protoId, 16) + ",len:" + bodyLen);
                byte[] cmdBytes = new byte[bodyLen];
                Array.Copy(m_readBuffer, m_beginOffset + 4 + 2, cmdBytes, 0, bodyLen);
                m_beginOffset += packetLen;

                if (m_beginOffset >= (m_readBuffer.Length / 2))
                {
                    int offset = m_endOffset - m_beginOffset;
                    Array.Copy(m_readBuffer, m_beginOffset, m_readBuffer, 0, offset);
                    m_endOffset = offset;
                    m_beginOffset = 0;
                }

                if (unpackCallback != null)
                {
                    var p = new ReturnPacket(protoId, cmdBytes);
                    unpackCallback(p);
                }
            }
        }
    }
}

4. Socket类，代码如下：

using Cmd;
using ProtoBuf;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using UnityEngine;
using SystemThreadPriority = System.Threading.ThreadPriority;

namespace Network
{
    // 为兼容老接口
    public enum NetworkDataType
    {
        SendWait,               // 发送，并等待返回
        SendOnly,               // 只发送
    }

    public class NetworkSocket
    {
        const float DurationToTurnFlower = 1.2f;                    // 发包时，从锁屏到转菊花的时间
        const float MaxSendingDuration = 3f;                        // 发送的最大时间，超过此时间将会重连，或断开连接
        const int MaxResendTimes = 3;                               // 最大重发次数

        // 阻塞
        float m_blockTimer;
        BlockState m_blockState = BlockState.Idle;
        public event Action EventLockScreen;
        public event Action EventTurnFlower;
        public event Action EventEndBlock;

        // 事件
        public event Action<NetworkSocket> EventDisconnect;
        public event Action<Action> EventRelogin;
        Action m_eventConnectedSucceed;
        Action m_eventConnectedFailed;
        Action m_eventReloginSucceed;

        TcpClient m_tcpClient;
        string m_host;
        int m_port;
        NetworkState m_state = NetworkState.Disconnecting;

        // 发包
        Queue<SendingPacket> m_forSendingPackets = new Queue<SendingPacket>();                      // 要发送的包的队列
        SendingPacket m_sendingPacket;                                                              // 当前正在发送的包
        float m_sendingTimer;

        // 重发
        SendingPacket m_resendPacket;                                                               // 重发的包
        float m_resendTimes;                                                                        // 重发次数

        // 收包
        UnpackTool m_unpackTool = new UnpackTool();                                                 // 解包工具
        byte[] m_receivedBuffer = new byte[256 * 1024];                                             // 收包临时缓存
        Thread m_listenInThread;                                                                    // 监听收包线程
        Queue<ReturnPacket> m_receivedPackets = new Queue<ReturnPacket>();                          // 收到的包的缓存

        #region Properties

        public bool Connected
        {
            get { return m_tcpClient != null && m_tcpClient.Connected; }
        }

        NetworkState State
        {
            get { return m_state; }
            set
            {
                //Debug.Log(string.Format("#[Network]Change network state from {0} to {1}", m_state, value));
                m_state = value;
            }
        }

        #endregion

        #region State

        enum NetworkState
        {
            Connecting,             // 连接中
            ConnectedSucceed,       // 连接成功
            ConnectedFailed,        // 连接失败

            Idle,                   // 空闲

            Sending,                // 发送中

            Resend,                 // 重发
            Resending,              // 重发中

            Disconnect,             // 断开连接
            Disconnecting,          // 连接断开中
        }

        // 阻塞状态管理
        enum BlockState
        {
            Idle,
            LockScreen,
            ScreenLocking,
            TurnFlower,
            FlowerTurning,
            EndBlock,
        }

        #endregion

        #region static

        public static EProtoId? GetProtoId(Type type)
        {
            var idProp = type.GetProperty("id");
            if (idProp == null)
            {
                Debug.LogError("#[Network]idProp==null, type: " + type);
                return null;
            }

            var attributes = idProp.GetCustomAttributes(typeof(DefaultValueAttribute), false);
            if (attributes == null || attributes.Length <= 0)
            {
                Debug.LogError("#[Network]attributes == null || attributes.Length <= 0, type: " + type);
                return null;
            }

            var attribute = attributes[0] as DefaultValueAttribute;
            if (attribute == null)
            {
                Debug.LogError("#[Network]attribute==null, type: " + type);
                return null;
            }

            return (EProtoId)attribute.Value;
        }

        #endregion

        #region 状态机 & 监听回包

        public void Update()
        {
            #region 阻塞

            bool blocking = m_forSendingPackets.Count > 0 && State != NetworkState.Disconnecting;

            switch (m_blockState)
            {
                case BlockState.Idle:
                    if (blocking)
                        m_blockState = BlockState.LockScreen;
                    break;

                case BlockState.LockScreen:
                    m_blockState = BlockState.ScreenLocking;
                    m_blockTimer = 0;
                    if (EventLockScreen != null)
                        EventLockScreen();
                    break;

                case BlockState.ScreenLocking:
                    if (blocking)
                    {
                        m_blockTimer += Time.deltaTime;
                        if (m_blockTimer >= DurationToTurnFlower)
                            m_blockState = BlockState.TurnFlower;
                    }
                    else
                        m_blockState = BlockState.EndBlock;
                    break;

                case BlockState.TurnFlower:
                    m_blockState = BlockState.FlowerTurning;
                    if (EventTurnFlower != null)
                        EventTurnFlower();
                    break;

                case BlockState.FlowerTurning:
                    if (!blocking)
                        m_blockState = BlockState.EndBlock;
                    break;

                case BlockState.EndBlock:
                    m_blockState = BlockState.Idle;
                    if (EventEndBlock != null)
                        EventEndBlock();
                    break;

                default:
                    throw new InvalidOperationException("Unknown block state: " + m_blockState);
            }

            #endregion

            #region 状态机

            switch (m_state)
            {
                // 连接
                case NetworkState.Connecting:
                    if (Connected)
                        State = NetworkState.ConnectedSucceed;
                    break;

                case NetworkState.ConnectedSucceed:
                    {
                        State = NetworkState.Idle;
                        if (m_eventConnectedSucceed != null)
                        {
                            m_eventConnectedSucceed();
                            m_eventConnectedSucceed = null;
                            m_eventConnectedFailed = null;
                        }
                    }
                    break;

                case NetworkState.ConnectedFailed:
                    {
                        State = NetworkState.Disconnect;
                        if (m_eventConnectedFailed != null)
                        {
                            m_eventConnectedFailed();
                            m_eventConnectedSucceed = null;
                            m_eventConnectedFailed = null;
                        }
                    }
                    break;

                // 空闲
                case NetworkState.Idle:
                    {
                        // 发包
                        if (m_forSendingPackets.Count > 0)
                        {
                            m_sendingTimer = 0;
                            ReallySend();
                        }

                        // 重发成功的时机
                        if (m_resendPacket != null)
                        {
                            if (!m_forSendingPackets.Contains(m_resendPacket))      // 表示重发成功
                            {
                                m_resendPacket = null;
                                m_resendTimes = 0;

                                if (m_eventReloginSucceed != null)
                                {
                                    m_eventReloginSucceed();
                                    m_eventReloginSucceed = null;
                                }
                            }
                        }
                    }
                    break;

                case NetworkState.Sending:
                    {
                        m_sendingTimer += Time.deltaTime;
                        if (m_sendingTimer > MaxSendingDuration)
                            State = m_resendTimes < MaxResendTimes ? NetworkState.Resend : NetworkState.Disconnect;
                    }
                    break;

                // 重发
                case NetworkState.Resend:
                    {
                        State = NetworkState.Resending;

                        m_resendTimes++;

                        // 第一次重连
                        if (m_resendPacket == null)
                        {
                            // 为什么要这样做?因为重连操作，连接成功之后要优先发重登录的包。
                            m_resendPacket = m_forSendingPackets.FirstOrDefault(p => p.SendWait);
                            var tempQueue = new Queue<SendingPacket>(m_forSendingPackets);     // 先出队
                            m_forSendingPackets.Clear();
                            EventRelogin(() =>
                            {
                                for (int i = 0; i < tempQueue.Count; i++)
                                    m_forSendingPackets.Enqueue(tempQueue.Dequeue());           // 再入队
                            });
                        }
                        else
                        {
                            EventRelogin(null);
                        }

                        Debug.Log("#[Network]断线重连，重连次数：　" + m_resendTimes);
                    }
                    break;

                case NetworkState.Resending:
                    break;

                // 断开连接
                case NetworkState.Disconnect:
                    {
                        m_resendTimes = 0;
                        State = NetworkState.Disconnecting;
                        if (EventDisconnect != null)
                            EventDisconnect(this);
                    }
                    break;

                case NetworkState.Disconnecting:
                    // 此时应该在弹框中
                    break;

                default:
                    throw new InvalidOperationException("Unknown state: " + m_state);
            }

            #endregion

            #region 监听处理回包

            // 监听
            if (Connected)
            {
                if (m_listenInThread == null)
                    m_listenInThread = new Thread(obj => ListenInReturnPackets());

                if (m_listenInThread.ThreadState == ThreadState.Unstarted)
                {
                    m_listenInThread.Priority = SystemThreadPriority.AboveNormal;
                    m_listenInThread.Start();
                }
            }
            else
            {
                if (m_listenInThread != null && m_listenInThread.IsAlive)
                    m_listenInThread.Abort();
            }

            // 处理回包
            if (m_receivedPackets.Count > 0)
                ProcessReturnPackets();

            #endregion
        }

        #endregion

        #region 连接

        public void Connect(string host, int port)
        {
            Connect(host, port, null, null);
        }

        public void Connect(string host, int port, Action onSucceed, Action onFailed)
        {
            if (string.IsNullOrEmpty(host))
                throw new ArgumentException("host");

            if (State == NetworkState.Connecting)
                return;

            State = NetworkState.Connecting;

            // 断开原有连接
            Disconnect();

            m_eventConnectedSucceed = onSucceed;
            m_eventConnectedFailed = onFailed;
            m_host = host;
            m_port = port;

            IPAddress[] addresses = null;
            try
            {
                addresses = Dns.GetHostAddresses(host);
            }
            catch (Exception ex)
            {
                Debug.LogError("#[Network]Dns.GetHostAddresses(ip) failed, ex: " + ex);
            }

            // 是否是ipv6
            bool isIpv6 = addresses != null && addresses.Length > 0 && addresses[0].AddressFamily == AddressFamily.InterNetworkV6;

            try
            {
                m_tcpClient = isIpv6 ? new TcpClient(AddressFamily.InterNetworkV6) : new TcpClient();
                m_tcpClient.BeginConnect(host, port, r =>
                {
                    if (Connected)
                    {
                        Debug.Log(string.Format("#[Network]Connect to server succeed, host: {0}, port: {1}, ipv6: {2}", host, port, isIpv6));
                        State = NetworkState.ConnectedSucceed;
                    }
                    else
                    {
                        Debug.Log(string.Format("#[Network]Connect to server failed, host: {0}, port: {1}, ipv6: {2}", host, port, isIpv6));
                        State = NetworkState.ConnectedFailed;
                    }
                }, null);
            }
            catch (Exception ex)
            {
                Debug.Log(string.Format("#[Network]Connect to server failed, host: {0}, port: {1}, ipv6: {2}, ex: {2}", host, port, isIpv6, ex));
                State = NetworkState.ConnectedFailed;
            }
        }

        public void Reconnect()
        {
            Reconnect(null, null);
        }

        public void Reconnect(Action onSucceed, Action onFailed)
        {
            if (!string.IsNullOrEmpty(m_host))      // 是否有连接过
                Connect(m_host, m_port, onSucceed, onFailed);
        }

        /// <summary>
        /// 断线重连
        /// </summary>
        public void Relogin(Action callback)
        {
            State = NetworkState.Resend;
            m_eventReloginSucceed = callback;
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        public void Disconnect()
        {
            // close socket
            if (Connected)
            {
                try
                {
                    m_tcpClient.GetStream().Close();
                    m_tcpClient.Close();
                }
                catch (Exception ex)
                {
                    Debug.LogError("#[Network]Error when disconnect socket, ex: " + ex);
                    m_tcpClient.Close();
                }
            }
            m_tcpClient = null;

            if (m_listenInThread != null && m_listenInThread.IsAlive)
                m_listenInThread.Abort();
            m_listenInThread = null;
        }

        public void SetToNoDelayMode()
        {
            if (m_tcpClient != null)
            {
                m_tcpClient.NoDelay = true;
                m_tcpClient.ReceiveBufferSize = 32768;
                m_tcpClient.SendBufferSize = 32768;
            }
        }

        #endregion

        #region 发包

        // 发包，为兼容老接口。
        public bool Send<T>(T obj, NetworkDataType option = NetworkDataType.SendOnly, EProtoId? returnId = null)
            where T : class
        {
            if (option == NetworkDataType.SendWait)
            {
                var sendId = GetProtoId(typeof(T));
                if (sendId == null)
                {
                    Debug.LogError(string.Format("#[Network]Send failed, cann't get EProtoId, send type: {0}.", typeof(T)));
                    return false;
                }

                Debug.Log("#[Network]SendWait: " + sendId.Value);

                var p = new SendingPacket(sendId.Value, obj)
                {
                    SendWait = true,
                    ExpectedReturnId = returnId,
                    OnPacketReturn = ret =>
                    {
                        NCConfig.OnReceiveMessageHandler callback;
                        if (NCConfig.dictCallback.TryGetValue(ret.ProtoId, out callback))
                        {
                            var retObj = NCConfigUnpack.GetProtocolObject(ret.ProtoId, ret.Body);
                            callback(retObj);
                        }
                    }
                };

                m_forSendingPackets.Enqueue(p);
                return true;
            }
            else
            {
                return SendOnly<T>(obj);
            }
        }

        // 发包，等待回包模式
        public bool SendWait<T1, T2>(T1 obj, Action<T2> onReturn)
            where T1 : class
            where T2 : class
        {
            var sendId = GetProtoId(typeof(T1));
            var returnId = GetProtoId(typeof(T2));
            if (sendId == null || returnId == null)
            {
                Debug.LogError(string.Format("#[Network]Send wait failed, cann't get EProtoId, send type: {0}, return type: {1}", typeof(T1), typeof(T2)));
                return false;
            }

            Debug.Log("#[Network]SendWait: " + sendId.Value);

            var p = new SendingPacket(sendId.Value, obj);
            p.SendWait = true;
            p.ExpectedReturnId = returnId.Value;
            p.OnPacketReturn = (ret) =>
            {
                var stream = new MemoryStream(ret.Body);
                var t2Obj = Serializer.Deserialize<T2>(stream);
                if (t2Obj != null)
                    onReturn(t2Obj);
                else
                    Debug.LogError("#[Network]Cann't convert return packet to type: " + typeof(T2));
            };
            m_forSendingPackets.Enqueue(p);
            return true;
        }

        // 发包，只发送，不等待回包模式
        public bool SendOnly<T>(T obj) where T : class
        {
            var protoId = GetProtoId(typeof(T));
            if (protoId == null)
            {
                Debug.LogError("#[Network]Send only failed, cann't get EProtoId, type: " + typeof(T));
                return false;
            }

            Debug.Log("#[Network]SendOnly: " + protoId.Value);

            var p = new SendingPacket(protoId.Value, obj);
            p.SendWait = false;
            m_forSendingPackets.Enqueue(p);
            return true;
        }

        void ReallySend()
        {
            if (!Connected)
            {
                Reconnect();
                return;
            }

            var p = m_forSendingPackets.Peek();
            if (p == null)
                throw new ArgumentNullException("p");

            try
            {
                var buffer = m_tcpClient.GetStream();
                if (buffer.CanWrite)
                {
                    p.UpdateSequenceId();
                    var bytes = p.GetBytes();
                    buffer.Write(bytes, 0, bytes.Length);
                    Debug.Log(string.Format("#[Network]Really send data, protoId: {0}, send wait: {1}.", p.ProtoId, p.SendWait));

                    if (p.SendWait)
                    {
                        m_sendingPacket = p;
                        State = NetworkState.Sending;
                    }
                    else
                    {
                        m_sendingPacket = null;
                        m_forSendingPackets.Dequeue();
                        State = NetworkState.Idle;
                    }
                }
                else
                {
                    Debug.LogError("#[Network]!buffer.CanWrite");
                }
            }
            catch (Exception ex)
            {
                Debug.LogError("#[Network]Send failed!!! ex: " + ex);
            }
        }

        #endregion

        #region 收包

        // 监听回包
        void ListenInReturnPackets()
        {
            while (Connected)
            {
                try
                {
                    var buffer = m_tcpClient.GetStream();
                    if (buffer.CanRead)
                    {
                        int len = buffer.Read(m_receivedBuffer, 0, m_receivedBuffer.Length);
                        if (len > 0)
                        {
                            m_unpackTool.UnpackData(m_receivedBuffer, len, p =>
                            {
                                if (p == null)
                                    throw new ArgumentNullException("p");

                                Debug.Log("#[Network]Received packet: " + p.ProtoId);

                                lock (this)
                                    m_receivedPackets.Enqueue(p);
                            });
                        }
                    }
                    else
                        Debug.LogError("#[Network]!buffer.CanRead");

                    Thread.Sleep(100);
                }
                catch (Exception ex)
                {
                    Debug.LogError("#[Network]Read return packet failed, Exception:
" + ex);
                }
            }
        }

        void ProcessReturnPackets()
        {
            if (m_receivedPackets.Count <= 0)
                return;

            ReturnPacket ret;
            lock (this)
                ret = m_receivedPackets.Dequeue();

            if (ret == null)
                return;

            if (ret.ProtoId == 0)                                 // 心跳包
                ProcessHeartBeat(ret);
            else if (ret.ProtoId == EProtoId.ERROR_CODE_S)        // 错误码
            {
                // [dev]
                //MemoryStream buffer = new MemoryStream(ret.Body);
                //var errorCode = Serializer.Deserialize<MessageErrorCode>(buffer);
                //Debug.Log(string.Format("#[Network]Error code: {0}", errorCode.code));
            }
            else                                                // 正常的包
            {
                bool isSendWait = m_sendingPacket != null && (m_sendingPacket.ExpectedReturnId == null || m_sendingPacket.ExpectedReturnId == ret.ProtoId);
                if (isSendWait)                                                                         // 为客户端主动发，等待反馈的情况
                {
                    if (m_sendingPacket.OnPacketReturn != null)
                        m_sendingPacket.OnPacketReturn(ret);
                    m_sendingPacket = null;
                    m_forSendingPackets.Dequeue();
                    State = NetworkState.Idle;
                }
                else if (NCConfig.dictCallback.ContainsKey(ret.ProtoId))                                  // 可能为服务器主动推的情况
                {
                    var callback = NCConfig.dictCallback[ret.ProtoId];
                    var retObj = NCConfigUnpack.GetProtocolObject(ret.ProtoId, ret.Body);
                    callback(retObj);
                }
                else
                {
                    Debug.LogError("#[Network]Unprocessed return packet, protoId: " + ret.ProtoId);
                }
            }
        }

        void ProcessHeartBeat(ReturnPacket p)
        {
            if (p.ProtoId != 0)
                throw new ArgumentException("p.ProtoId != 0");

            byte[] bytes = new byte[6] { 0x2, 0x0, 0x0, 0x0, 0x0, 0x0 };

            try
            {
                var buffer = m_tcpClient.GetStream();
                if (buffer.CanWrite)
                {
                    Debug.Log("#[Network]Send heart beat");
                    buffer.Write(bytes, 0, 6);
                }
                else
                {
                    Debug.LogError("#[Network]!buffer.CanWrite");
                }
            }
            catch (Exception ex)
            {
                Debug.LogError("#[Network]Send heart beat failed, ex: " + ex);
            }
        }

        #endregion
    }
}

转载请注明出处： http://www.cnblogs.com/jietian331/p/5726332.html