网络通讯之Socket-Tcp（二）

网络通讯之Socket-Tcp  分成2部分讲解：

网络通讯之Socket-Tcp（一）：

1.如何理解Socket

2.Socket通信重要函数

3.Socket Tcp 调用的基本流程图

4.简单Socket实例

 

网络通讯之Socket-Tcp（二）：

1.完善Socket实例【黏包拆包 收发数据】

2.优化Socket

3.Socket网络安全

 

黏包 拆包需要明白的概念：

客户端给服务器发（协议）消息，tcp是字节流的传输方式，所以我们给服务器发的消息 都需要转化为byte[]数组（包体或消息体）。

为了能够区分一个完整的消息，给服务器发数据包的时候，我们会把 消息体的长度（简称包头） 也写入内存流，这样我们就可以根据 包头的大小 来确定 从内存流中读取多少大小的消息体。

给服务器发的是这样的 数据包。

网络安全（通信安全）：大家可行根据项目需求是否需要。

对消息体进行 压缩、异或加密、 crc校验、保证消息不被破解 更改。封装数据包之后形成 新数据包 。

经过封装之后 ，给服务器发的是 新数据包。

Socket优化（通信优化）：代码没实现，大家可自行实现

长时间的频繁收发包，导致手机网卡发热，为了防止这种现象，策略是 小包合大包，分帧处理。

 

实例上图：

客户端给服务器发送一个 赵不灰，服务器给客户端 回一个赵老三的消息。

按 A键 连接服务器，按 S键 发送消息给服务器。

 

 

 先看服务器代码：

 主Program.cs

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace ZhaoBuHui.GateWayServer
{
    public sealed class ServerConfig
    {
        public static string ip = "192.168.124.2";
        public static int point = 8082;
    }

    class Program
    {
        private static Socket m_ListenSocket;
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            StartListen();
        }
        public static void StartListen()
        {
            m_ListenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            m_ListenSocket.Bind(new IPEndPoint(IPAddress.Parse(ServerConfig.ip), ServerConfig.point));
            m_ListenSocket.Listen(100);
            Console.WriteLine("启动监听{0}成功", m_ListenSocket.LocalEndPoint.ToString());
            Thread thread = new Thread(ListenClientConnect);
            thread.Start();
        }
        /// <summary>
        /// 监听客户端链接
        /// </summary>
        /// <param name="obj"></param>
        private static void ListenClientConnect(object obj)
        {
            while (true)
            {
                try
                {
                    Socket m_ClientSocket = m_ListenSocket.Accept();
                    IPEndPoint iPEndPoint = (IPEndPoint)m_ClientSocket.RemoteEndPoint;
                    Console.WriteLine("收到客户端IP={0},Port={1}已经连接", iPEndPoint.Address.ToString(), iPEndPoint.Port.ToString());
                    PlayerClientSocket playerClientSocket = new PlayerClientSocket(m_ClientSocket);
                    new PlayerInfo(playerClientSocket);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                }
            }
        }
    }
}

1.每连接进来一个客户端，就会返回一个clientsocket，此clientsocket 负责与客户端的socket 通信。【socket tcp的特性是 点对点】，因此每连接进来我们就会创建一个 PlayerClientSocket。PlayerClientSocket需要有一个Manager 进行管理，感兴趣的同学可以自行实现。

 

PlayerClientSocket.cs  玩家客户端socket 

using System;
using System.Collections.Generic;
using System.Net.Sockets;

namespace ZhaoBuHui.GateWayServer
{
    //玩家客户端socket
    public class PlayerClientSocket
    {
        private Socket m_Socket;

        /// <summary>
        /// 接收数据缓存区
        /// </summary>
        private byte[] m_Receive = new byte[1024];
        private TestMemoryStreamUtil m_ReceiveMS = new TestMemoryStreamUtil();

        //发送数据队列
        private Queue<byte[]> m_SendQueue = new Queue<byte[]>();
        //压缩阈值
        private const int m_CompressLen = 200;//255也行 这个自定义 
        public PlayerClientSocket(Socket socket)
        {
            m_Socket = socket;
            ReceiveMsg();
        }

        //发送消息
        public void SendMsg(ushort protoId, byte[] data)
        {
            lock (m_SendQueue)
            {
                m_SendQueue.Enqueue(PackageData(protoId, data));
            }
            BeginSendMsg();
        }

        //封装数据【网络安全：压缩(优化)、加密、crc校验】
        private byte[] PackageData(ushort protoId, byte[] data)
        {
            bool bCompress = data.Length > m_CompressLen;
            //压缩
            if (bCompress) data = ZlibHelper.CompressBytes(data);
            //加密
            data = SecurityUtil.Xor(data);
            //Crc16
            ushort crc = Crc16.CalculateCrc16(data);
            TestMemoryStreamUtil ms = new TestMemoryStreamUtil();
            ms.WriteUShort((ushort)(data.Length + 5));//写入长度 压缩1字节 crc2字节 协议号2字节
            ms.WriteBool(bCompress);//写入压缩
            ms.WriteUShort(crc);//写入crc
            ms.WriteUShort(protoId);//写入协议号
            ms.Write(data, 0, data.Length);//写入data
            return ms.ToArray();
        }

        private void BeginSendMsg()
        {
            while (true)
            {
                lock (m_SendQueue)
                {
                    if (m_SendQueue.Count <= 0) break; ;
                    byte[] data = m_SendQueue.Dequeue();
                    m_Socket.BeginSend(data, 0, data.Length, SocketFlags.None, SendCallBack, m_Socket);
                }
            }
        }

        private void SendCallBack(IAsyncResult ar)
        {
            try
            {
                if (!ar.CompletedSynchronously) return;
                m_Socket.EndSend(ar);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }

        //接收消息
        private void ReceiveMsg()
        {
            try
            {
                //开始接收
                m_Socket.BeginReceive(m_Receive, 0, m_Receive.Length, SocketFlags.None, ReceiveCallBack, m_Socket);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }

        private void ReceiveCallBack(IAsyncResult ar)
        {
            try
            {
                int len = m_Socket.EndReceive(ar);
                if (len > 0)
                {
                    m_ReceiveMS.Position = m_ReceiveMS.Length;
                    m_ReceiveMS.Write(m_Receive, 0, len);
                    while (true)
                    {
                        //不完整包过来
                        if (len > 2)
                        {
                            m_ReceiveMS.Position = 0;
                            ushort currMsglen = m_ReceiveMS.ReadUShort();//当前包体的长度（压缩 crc 协议号 数据）
                            ushort currFullLen = (ushort)(currMsglen + 2);//包体+包头
                            //过来一个完整包
                            if (len >= currFullLen)
                            {
                                m_ReceiveMS.Position = 2;
                                byte[] currFullData = new byte[currMsglen];
                                m_ReceiveMS.Read(currFullData, 0, currMsglen);
                                //解封数据
                                currFullData = UnBlockData(currFullData, out ushort protoId);
                                if (currFullData == null) continue;
                                TestCommonEvent.Dispatch(protoId, currFullData);
                                //处理剩余字节
                                if (len - currFullLen > 0)
                                {
                                    byte[] residueData = new byte[len - currFullLen];
                                    m_ReceiveMS.Position = currFullLen;
                                    m_ReceiveMS.Read(residueData, 0, len - currFullLen);

                                    m_ReceiveMS.SetLength(0);
                                    m_ReceiveMS.Position = 0;
                                    m_ReceiveMS.Write(residueData, 0, residueData.Length);
                                    residueData = null;
                                }
                                else
                                {
                                    m_ReceiveMS.SetLength(0);
                                    break;
                                }
                            }
                            else
                            {
                                break; //没有收到一个完整的包 等待下一次处理
                            }
                        }
                        else
                        {
                            break;//还没收到数据
                        }
                    }
                    ReceiveMsg();
                }
                else
                {
                    Console.WriteLine("服务器断开链接");
                }
            }
            catch (Exception)
            {
                Console.WriteLine("服务器断开链接");
            }
        }

        //解封数据需要跟封装数据顺序一致 否则拿不到正确数据
        private byte[] UnBlockData(byte[] data, out ushort protoId)
        {
            TestMemoryStreamUtil ms = new TestMemoryStreamUtil();
            ms.SetLength(0);
            ms.Write(data, 0, data.Length);
            ms.Position = 0;
            bool isCompress = ms.ReadBool();
            ushort crc = ms.ReadUShort();
            protoId = ms.ReadUShort();
            ms.Position = 5;
            data = new byte[data.Length - 5];//-5是因为 压缩1字节 crc2字节 协议号2字节 拿到的是真正消息的长度
            ms.Read(data, 0, data.Length);//加密数据
            ushort createCrc = Crc16.CalculateCrc16(data);
            if (createCrc != crc)
            {
                Console.WriteLine("CRC Fail!");
                return null;
            }
            data = SecurityUtil.Xor(data);//拿到压缩之后的数据
            if (isCompress)
            {
                data = ZlibHelper.DeCompressBytes(data);//解压 原始数据
            }
            ms.Dispose();
            return data;
        }
    }
}

注意：封装数据 和解封数据 写入 读取顺序要一致，否则拿不到正确数据。前后端也必须一致。包括 异或加密算法 、crc16。

TestCommonEvent  不知道的请点击

 

 协议id类：

public class TestCommonEventId
{
    //事件
    public const ushort _playerInfo = 10001;
}


public class TestCommonProtoId
{
    //协议
    public const ushort test1 = 20001;
}

 

 测试的 PlayerInfo.cs 

using Google.Protobuf;
using System;

namespace ZhaoBuHui.GateWayServer
{
    class PlayerInfo : IDisposable
    {
        PlayerClientSocket playerClientSocket;
        public PlayerInfo(PlayerClientSocket clientSocket)
        {
            playerClientSocket = clientSocket;
            TestCommonEvent.AddEventListener(TestCommonProtoId.test1, Test1CallBack);
        }

        public void Dispose()
        {
            TestCommonEvent.RemoveEventListener(TestCommonProtoId.test1, Test1CallBack);
        }

        private void Test1CallBack(object obj)
        {
            test1 protoMsg = test1.Parser.ParseFrom((byte[])obj);
            string name = protoMsg.Name;
            int age = protoMsg.Age;
            string Sex = protoMsg.Sex;
            Console.WriteLine(string.Format("name = {0},age={1},Sex ={2}", name, age, Sex));

            test1 proto = new test1
            {
                Age = new Random().Next(999, 1999),
                Sex = "boy",
                Name = "赵老三"
            };
            playerClientSocket.SendMsg(TestCommonProtoId.test1, proto.ToByteArray());

        }
    }
}

监听客户端发过来的消息，打印出来，然后又给客户端 回了一个消息。

test1： 用google protobuf 生成的c# 代码，不知道的请点击

----------------------------以下是客户端-------------------------------
客户端代码：和服务器基本一样，写好一个 复制粘贴过来就可以了。

TestSocketTcpRoutine.cs  socketTcp访问器

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;

public class TestSocketTcpRoutine
{
    private Socket m_ClientSocket;

    // 是否连接过socket
    private bool m_bDoConnect;
    // 是否连接成功
    private bool m_IsConnectSuccess;
    private Action<bool> m_ConnectCompletedHander;

    /// <summary>
    /// 接收数据缓存区
    /// </summary>
    private byte[] m_Receive = new byte[1024];
    private TestMemoryStreamUtil m_ReceiveMS = new TestMemoryStreamUtil();
    private TestCommonEvent m_CommonEvent = new TestCommonEvent();

    //发送数据队列
    private Queue<byte[]> m_SendQueue = new Queue<byte[]>();
    private TestMemoryStreamUtil m_SendMS = new TestMemoryStreamUtil();
    //压缩阈值
    private const int m_CompressLen = 200;//255也行 这个自定义 


    public void OnUpdate()
    {
        if (m_bDoConnect)
        {
            m_bDoConnect = false;
            m_ConnectCompletedHander?.Invoke(m_IsConnectSuccess);
        }
        if (!m_IsConnectSuccess) return;
        BeginSendMsg();
    }

    //发送消息
    public void SendMsg(ushort protoId, byte[] data)
    {
        lock (m_SendQueue)
        {
            m_SendQueue.Enqueue(PackageData(protoId, data));
        }
    }
    //封装数据【网络安全：压缩(优化)、加密、crc校验】
    private byte[] PackageData(ushort protoId, byte[] data)
    {
        bool bCompress = data.Length > m_CompressLen;
        //压缩
        if (bCompress) data = ZlibHelper.CompressBytes(data);
        //加密
        data = SecurityUtil.Xor(data);
        //crc
        ushort crc = Crc16.CalculateCrc16(data);
        TestMemoryStreamUtil ms = new TestMemoryStreamUtil();
        ms.SetLength(0);
        ms.WriteUShort((ushort)(data.Length + 5));//写入长度 压缩1字节 crc2字节 协议号2字节
        ms.WriteBool(bCompress);//写入压缩
        ms.WriteUShort(crc);//写入crc
        ms.WriteUShort(protoId);//写入协议号
        ms.Write(data, 0, data.Length);//写入data
        return ms.ToArray();
    }

    //开始发送消息
    private void BeginSendMsg()
    {
        while (true)
        {
            lock (m_SendQueue)
            {
                if (m_SendQueue.Count <= 0) break; ;
                byte[] data = m_SendQueue.Dequeue();
                m_ClientSocket.BeginSend(data, 0, data.Length, SocketFlags.None, SendCallBack, m_ClientSocket);
            }
        }
    }

    //发送回调
    private void SendCallBack(IAsyncResult ar)
    {
        try
        {
            if (!ar.CompletedSynchronously) return;
            m_ClientSocket.EndSend(ar);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }

    //连接socket服务器
    public void Connect(string ip, int point, Action<bool> bConnectComplete)
    {
        m_ConnectCompletedHander = bConnectComplete;
        if ((m_ClientSocket != null && m_ClientSocket.Connected) || m_IsConnectSuccess) return;
        m_IsConnectSuccess = false;
        try
        {
            m_ClientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            m_ClientSocket.BeginConnect(new IPEndPoint(IPAddress.Parse(ip), point), ConnectCallBack, m_ClientSocket);
        }
        catch (Exception ex)
        {
            m_ConnectCompletedHander?.Invoke(m_IsConnectSuccess);
            UnityEngine.Debug.LogError(ex.ToString());
        }
    }

    //连接回调
    private void ConnectCallBack(IAsyncResult ar)
    {
        m_bDoConnect = true;
        if (m_ClientSocket.Connected)
        {
            ReceiveMsg();
            m_IsConnectSuccess = true;
        }
        else
        {
            m_IsConnectSuccess = false;
            UnityEngine.Debug.LogError("服务器断开链接");
            Dispose();
        }
        m_ClientSocket.EndConnect(ar);
    }

    //接收消息
    private void ReceiveMsg()
    {
        try
        {
            //开始接收
            m_ClientSocket.BeginReceive(m_Receive, 0, m_Receive.Length, SocketFlags.None, ReceiveCallBack, m_ClientSocket);
        }
        catch (Exception ex)
        {
            UnityEngine.Debug.LogError(ex.ToString());
        }
    }
    //接收回调
    private void ReceiveCallBack(IAsyncResult ar)
    {
        try
        {
            int len = m_ClientSocket.EndReceive(ar);
            if (len > 0)
            {
                m_ReceiveMS.Position = m_ReceiveMS.Length;
                m_ReceiveMS.Write(m_Receive, 0, len);
                while (true)
                {
                    //不完整包过来
                    if (len > 2)
                    {
                        m_ReceiveMS.Position = 0;
                        ushort currMsglen = m_ReceiveMS.ReadUShort();//当前包体的长度（压缩 crc 协议号 数据）
                        ushort currFullLen = (ushort)(currMsglen + 2);//包体+包头
                        //过来一个完整包
                        if (len >= currFullLen)
                        {
                            m_ReceiveMS.Position = 2;
                            byte[] currFullData = new byte[currMsglen];
                            m_ReceiveMS.Read(currFullData, 0, currMsglen);
                            //解封数据
                            currFullData = UnBlockData(currFullData, out ushort protoId);
                            if (currFullData == null) continue;
                            //派发消息
                            TestGameEntry.EventMgr.commonEvent.Dispatch(protoId, currFullData);
                            //处理剩余字节
                            if (len - currFullLen > 0)
                            {
                                byte[] residueData = new byte[len - currFullLen];
                                m_ReceiveMS.Position = currFullLen;
                                m_ReceiveMS.Read(residueData, 0, len - currFullLen);

                                m_ReceiveMS.SetLength(0);
                                m_ReceiveMS.Position = 0;
                                m_ReceiveMS.Write(residueData, 0, residueData.Length);
                                residueData = null;
                            }
                            else
                            {
                                m_ReceiveMS.SetLength(0);
                                break;
                            }
                        }
                        else
                        {
                            break; //没有收到一个完整的包 等待下一次处理
                        }
                    }
                    else
                    {
                        break;//还没收到数据
                    }
                }
                ReceiveMsg();//递归循环接收
            }
            else
            {
                UnityEngine.Debug.LogError("服务器断开链接");
                Dispose();
            }
        }
        catch (Exception)
        {
            UnityEngine.Debug.LogError("服务器断开链接");
            Dispose();
        }
    }

    //解封数据需要跟封装数据顺序一致 否则拿不到正确数据
    private byte[] UnBlockData(byte[] data, out ushort protoId)
    {
        TestMemoryStreamUtil ms = new TestMemoryStreamUtil();
        ms.SetLength(0);
        ms.Write(data, 0, data.Length);
        ms.Position = 0;
        bool isCompress = ms.ReadBool();
        ushort crc = ms.ReadUShort();
        protoId = ms.ReadUShort();
        ms.Position = 5;
        data = new byte[data.Length - 5];//-5是因为 压缩1字节 crc2字节 协议号2字节 拿到的是真正消息的长度
        ms.Read(data, 0, data.Length);//加密数据
        ushort createCrc = Crc16.CalculateCrc16(data);
        if (createCrc != crc)
        {
            UnityEngine.Debug.LogError("CRC Fail!");
            return null;
        }
        data = SecurityUtil.Xor(data);//拿到压缩之后的数据
        if (isCompress)
        {
            data = ZlibHelper.DeCompressBytes(data);//解压 原始数据
        }
        ms.Dispose();
        return data;
    }

    public void Dispose()
    {
        m_bDoConnect = false;
        m_IsConnectSuccess = false;
        m_SendQueue.Clear();
    }
}

TestSocketManager.cs   不变，不知道的请点击

 

TestSocket.cs  测试代码

using Google.Protobuf;
using UnityEngine;

public class TestSocket : MonoBehaviour
{
    void Start()
    {
        TestGameEntry.EventMgr.commonEvent.AddEventListener(TestCommonProtoId.test1, Test1CallBack);
    }

    private void OnDestroy()
    {
        TestGameEntry.EventMgr.commonEvent.RemoveEventListener(TestCommonProtoId.test1, Test1CallBack);
    }

    private void Test1CallBack(object obj)
    {
        test1 protoMsg = test1.Parser.ParseFrom((byte[])obj);
        string name = protoMsg.Name;
        int age = protoMsg.Age;
        string Sex = protoMsg.Sex;
        UnityEngine.Debug.Log(string.Format("name = {0},age={1},Sex ={2}", name, age, Sex));
    }

    bool m_isConnectSuccess;
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.A))
        {
            TestGameEntry.SocketMgr.Connect("192.168.124.2", 8082, (bool isConnectSuccess) =>
             {
                 m_isConnectSuccess = true;
                 UnityEngine.Debug.Log("连接192.168.124.2:8082" + (isConnectSuccess ? "成功" : "失败"));
             });
        }

        if (Input.GetKeyDown(KeyCode.S))
        {
            if (!m_isConnectSuccess) return;
            test1 proto = new test1
            {
                Age = Random.Range(1, 100),
                Sex = "boy",
                Name = "赵不灰"
            };
            TestGameEntry.SocketMgr.SendMsg(TestCommonProtoId.test1, proto.ToByteArray());
        }
    }
}

 

--------------------------------------以下是扩展辅助类-------------------------------------------

 Crc16.cs  校验

public class Crc16
{
    // Table of CRC values for high-order byte
    private static readonly byte[] _auchCRCHi = new byte[] { 0x01, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x41 };

    // Table of CRC values for low-order byte
    private static readonly byte[] _auchCRCLo = new byte[] { 0x01, 0xC1, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3, 0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26, 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5, 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C, 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x41 };

    /// <summary>
    /// 获得CRC16效验码
    /// </summary>
    /// <param name="buffer"></param>
    /// <returns></returns>
    public static ushort CalculateCrc16(byte[] buffer)
    {
        byte crcHi = 0xff;  // high crc byte initialized
        byte crcLo = 0xff;  // low crc byte initialized
        for (int i = 0; i < buffer.Length; i++)
        {
            int crcIndex = crcHi ^ buffer[i];
            // calculate the crc lookup index
            crcHi = (byte)(crcLo ^ _auchCRCHi[crcIndex]);
            crcLo = _auchCRCLo[crcIndex];
        }
        return (ushort)(crcHi << 8 | crcLo);
    }
}

 

 SecurityUtil.cs   异或加密

public sealed class SecurityUtil
{
    #region xorScale 异或因子
    /// <summary>
    /// 异或因子
    /// </summary>
    private static readonly byte[] xorScale = new byte[] { 45, 66, 38, 55, 23, 254, 9, 165, 90, 19, 41, 45, 201, 58, 55, 37, 254, 185, 165, 169, 19, 171 };//.data文件的xor加解密因子
    #endregion

    /// <summary>
    /// 对数组进行异或[]
    /// </summary>
    /// <param name="buffer"></param>
    /// <returns></returns>
    public static byte[] Xor(byte[] buffer)
    {
        int iScaleLen = xorScale.Length;
        for (int i = 0; i < buffer.Length; i++)
        {
            buffer[i] = (byte)(buffer[i] ^ xorScale[i % iScaleLen]);
        }
        return buffer;
    }
}

 

ZlibHelper.cs   压缩帮助类

using ComponentAce.Compression.Libs.zlib;
using System;
using System.IO;

/// <summary>
/// 压缩帮助类
/// </summary>
public class ZlibHelper
{
    #region CompressBytes 对原始字节数组进行zlib压缩，得到处理结果字节数组
    /// <summary>
    /// 对原始字节数组进行zlib压缩，得到处理结果字节数组
    /// </summary>
    /// <param name="OrgByte">需要被压缩的原始Byte数组数据</param>
    /// <param name="CompressRate">压缩率：默认为zlibConst.Z_DEFAULT_COMPRESSION</param>
    /// <returns>压缩后的字节数组，如果出错则返回null</returns>
    public static byte[] CompressBytes(byte[] OrgByte, int CompressRate = zlibConst.Z_BEST_SPEED)
    {
        if (OrgByte == null) return null;

        using (MemoryStream OrgStream = new MemoryStream(OrgByte))
        {
            using (MemoryStream CompressedStream = new MemoryStream())
            {
                using (ZOutputStream outZStream = new ZOutputStream(CompressedStream, CompressRate))
                {
                    try
                    {
                        CopyStream(OrgStream, outZStream);
                        outZStream.finish();//重要！否则结果数据不完整！
                        //程序执行到这里，CompressedStream就是压缩后的数据
                        if (CompressedStream == null) return null;

                        return CompressedStream.ToArray();
                    }
                    catch
                    {
                        return null;
                    }
                }
            }
        }
    }
    #endregion

    #region DeCompressBytes 对经过zlib压缩的数据，进行解密和zlib解压缩，得到原始字节数组
    /// <summary>
    /// 对经过zlib压缩的数据，进行解密和zlib解压缩，得到原始字节数组
    /// </summary>
    /// <param name="CompressedBytes">被压缩的Byte数组数据</param>
    /// <returns>解压缩后的字节数组，如果出错则返回null</returns>
    public static byte[] DeCompressBytes(byte[] CompressedBytes)
    {
        if (CompressedBytes == null) return null;

        using (MemoryStream CompressedStream = new MemoryStream(CompressedBytes))
        {
            using (MemoryStream OrgStream = new MemoryStream())
            {
                using (ZOutputStream outZStream = new ZOutputStream(OrgStream))
                {
                    try
                    {
                        //-----------------------
                        //解压缩
                        //-----------------------
                        CopyStream(CompressedStream, outZStream);
                        outZStream.finish();//重要！
                        //程序执行到这里，OrgStream就是解压缩后的数据

                        if (OrgStream == null)
                        {
                            return null;
                        }
                        return OrgStream.ToArray();
                    }
                    catch
                    {
                        return null;
                    }
                }
            }
        }
    }
    #endregion

    #region CompressString 压缩字符串
    /// <summary>
    /// 压缩字符串
    /// </summary>
    /// <param name="SourceString">需要被压缩的字符串</param>
    /// <returns>压缩后的字符串，如果失败则返回null</returns>
    public static string CompressString(string SourceString, int CompressRate = zlibConst.Z_DEFAULT_COMPRESSION)
    {
        byte[] byteSource = System.Text.Encoding.UTF8.GetBytes(SourceString);
        byte[] byteCompress = CompressBytes(byteSource, CompressRate);
        if (byteCompress != null)
        {
            return Convert.ToBase64String(byteCompress);
        }
        else
        {
            return null;
        }
    }
    #endregion

    #region DecompressString 解压字符串
    /// <summary>
    /// 解压字符串
    /// </summary>
    /// <param name="SourceString">需要被解压的字符串</param>
    /// <returns>解压后的字符串，如果处所则返回null</returns>
    public static string DecompressString(string SourceString)
    {
        byte[] byteSource = Convert.FromBase64String(SourceString);
        byte[] byteDecompress = DeCompressBytes(byteSource);
        if (byteDecompress != null)
        {

            return System.Text.Encoding.UTF8.GetString(byteDecompress);
        }
        else
        {
            return null;
        }
    }
    #endregion

    #region CopyStream 拷贝流
    /// <summary>
    /// 拷贝流
    /// </summary>
    /// <param name="input"></param>
    /// <param name="output"></param>
    private static void CopyStream(Stream input, Stream output)
    {
        byte[] buffer = new byte[2000];
        int len;
        while ((len = input.Read(buffer, 0, 2000)) > 0)
        {
            output.Write(buffer, 0, len);
        }
        output.Flush();
    }
    #endregion

    #region GetStringByGZIPData 将解压缩过的二进制数据转换回字符串
    /// <summary>
    /// 将解压缩过的二进制数据转换回字符串
    /// </summary>
    /// <param name="zipData"></param>
    /// <returns></returns>
    public static string GetStringByGZIPData(byte[] zipData)
    {
        return (string)(System.Text.Encoding.UTF8.GetString(zipData));
    }
    #endregion
}

 

源码地址：http://www.componentace.com/download/  

 

 自行选择一个版本，我用的是 ZLIB.NET Free v.1.04 - Free

下载完成之后，解压，把zlib.net.dll   导入到unity客户端

服务端则导入源码文件（source）即可。

 

不懂的小伙伴可自行留言哈，欢迎大家提出批评和建议~