public class StreamHelper
    {
        #region 将消息转为包含消息头的字节数组
        /// <summary>
        /// 将消息转为包含消息头的字节数组
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public static byte[] GetWrappedMessage(Google.ProtocolBuffers.IMessage message)
        {
            byte[] buff = message.ToByteArray();
            CRC32 crc32 = new CRC32();
            crc32.Update(buff);

            MemoryStream ms = new MemoryStream();
            byte[] tag = BitConverter.GetBytes(Constants.Tag);
            byte[] len = BitConverter.GetBytes(buff.Length);
            byte[] crc = BitConverter.GetBytes(crc32.Value);

            ms.Write(tag, 0, tag.Length); // 写入标头
            ms.Write(len, 0, len.Length); // 写入消息长度
            ms.Write(crc, 0, crc.Length); // 写入crc32值
            ms.Write(buff, 0, buff.Length);

            byte[] result = ms.ToArray();
            ms.Close();

            return result;
        }
        #endregion

        #region 将消息写入流
        /// <summary>
        /// 将消息写入流
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static void WriteToStream(NetworkStream stream, Google.ProtocolBuffers.IMessage message)
        {
            byte[] buff = message.ToByteArray();
            CRC32 crc32 = new CRC32();
            crc32.Update(buff);

            byte[] tag = BitConverter.GetBytes(Constants.Tag);
            byte[] len = BitConverter.GetBytes(buff.Length);
            byte[] crc = BitConverter.GetBytes(crc32.Value);

            stream.Write(tag, 0, tag.Length); // 写入标头
            stream.Write(len, 0, len.Length); // 写入消息长度
            stream.Write(crc, 0, crc.Length); // 写入crc32值
            stream.Write(buff, 0, buff.Length);
        }
        #endregion

        #region 将消息写入Socket
        /// <summary>
        /// 将消息写入Socket
        /// </summary>
        /// <param name="socket"></param>
        /// <returns></returns>
        public static void WriteToSocket(Socket socket, Google.ProtocolBuffers.IMessage message)
        {
            byte[] buff = message.ToByteArray();
            CRC32 crc32 = new CRC32();
            crc32.Update(buff);

            byte[] tag = BitConverter.GetBytes(Constants.Tag);
            byte[] len = BitConverter.GetBytes(buff.Length);
            byte[] crc = BitConverter.GetBytes(crc32.Value);

            socket.SendBufferSize = Constants.HeadSize + buff.Length;

            socket.Send(tag); // 写入标头
            socket.Send(len); // 写入消息长度
            socket.Send(crc); // 写入crc32值
            socket.Send(buff);
        }
        #endregion

        #region 从NetworkStream读出所有字节
        /// <summary>
        /// 从NetworkStream读出所有字节
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static byte[] ReadAllBytes(NetworkStream stream)
        {
            byte[] head = new byte[Constants.HeadSize];
            if (stream.Read(head, 0, Constants.HeadSize) != Constants.HeadSize) // 传输头16位,仅校验数据使用
            {
                return null;
            }

            HeadInfo headInfo = new HeadInfo(head);
            if (headInfo.Tag != Constants.Tag) // 标头不正确
            {
                return null;
            }

            byte[] buff = new byte[headInfo.Len];
            int size = Math.Min(buff.Length, 4096); // 一次最多读取多少个字节
            int offset = 0;
            do
            {
                size = Math.Min(size, headInfo.Len - offset);
                offset += stream.Read(buff, offset, size);
                if (offset == headInfo.Len) // 接收到指定的长度
                {
                    CRC32 crc32 = new CRC32();
                    crc32.Update(buff);
                    if (crc32.Value == headInfo.Crc32Value) // 验证CRC32
                    {
                        return buff;
                    }
                }
            }
            while (stream.DataAvailable);

            Log.ErrorFormat("客户端请求失败: offset {0}, head len {1}", offset, headInfo.Len);

            return null;
        }
        #endregion

        #region 从Socket读出所有字节
        /// <summary>
        /// 从Socket读出所有字节
        /// </summary>
        /// <param name="socket"></param>
        /// <returns></returns>
        public static byte[] ReadAllBytes(Socket socket)
        {
            byte[] head = new byte[Constants.HeadSize];
            byte[] result = null;

            SocketError error = SocketError.Success;
            int maxRepeat = 5;
            int got = 0;
            int repeat = 0;

            do // 读取标头
            {
                got += socket.Receive(head, got, Constants.HeadSize - got, SocketFlags.None, out error);
                if (got == Constants.HeadSize || repeat > maxRepeat) // 接收完全或者重复10次仍然没接收
                {
                    break;
                }
                else if (got == 0) // 获取不到数据重复的次数
                {
                    ++repeat;
                }
            }
            while (error == SocketError.Success);

            if (got != Constants.HeadSize) // 验证标头长度
            {
                Log.Error("Head长度不正确");
                return null;
            }

            HeadInfo headInfo = new HeadInfo(head);
            if (headInfo.Tag != Constants.Tag) // 标头不正确
            {
                Log.ErrorFormat("Head.Tag不正确(应为{0}, 实际{1})", Constants.Tag, headInfo.Tag);
                return null;
            }

            result = new byte[headInfo.Len];
            repeat = 0;
            got = 0;
            do // 读取消息体
            {
                got += socket.Receive(result, got, result.Length - got, SocketFlags.None, out error);
                if (got == result.Length || repeat > maxRepeat) // 接收完全或者重复10次仍然没接收
                {
                    break;
                }
                else if (got == 0) // 获取不到数据重复的次数
                {
                    ++repeat;
                }
            }
            while (error == SocketError.Success);

            if (got != result.Length) // 验证长度
            {
                Log.ErrorFormat("长度不正确(应为{0}, 实际{1})", result.Length, got);
                return null;
            }

            CRC32 crc32 = new CRC32();
            crc32.Update(result);
            if (crc32.Value != headInfo.Crc32Value) // 验证CRC32
            {
                Log.ErrorFormat("CRC校验失败(应为{0}, 实际{1})", headInfo.Crc32Value, crc32.Value);
                return null;
            }

            return result;
        }
        #endregion

        #region 异步接收Socket数据(测试用)
        /// <summary>
        /// 异步接收Socket数据
        /// </summary>
        /// <param name="socket"></param>
        /// <returns></returns>
        public static byte[] ReceiveData(Socket socket)
        {
            ReceiveObject state = new ReceiveObject() { Client = socket };
            socket.BeginReceive(state.Buffer, 0, state.Buffer.Length, SocketFlags.None, new AsyncCallback(ReadCallback), state);
            state.ReceiveDone.WaitOne(socket.ReceiveTimeout); // 超时设置

            byte[] head = new byte[Constants.HeadSize];
            state.Stream.Seek(0, SeekOrigin.Begin);
            if (state.Stream.Read(head, 0, Constants.HeadSize) != Constants.HeadSize) // 读取标头
            {
                return null;
            }

            HeadInfo headInfo = new HeadInfo(head);
            if (headInfo.Tag != Constants.Tag) // 标头不正确
            {
                return null;
            }
            if (state.Stream.Length - 16 != headInfo.Len) // 验证长度
            {
                return null;
            }

            // state.Stream.Seek(16, SeekOrigin.Begin);
            byte[] result = new byte[state.Stream.Length - 16];
            state.Stream.Read(result, 0, result.Length); // 读取消息体

            CRC32 crc32 = new CRC32();
            crc32.Update(result);
            if (crc32.Value == headInfo.Crc32Value) // 验证CRC32
            {
                return result;
            }

            return null;
        }

        /// <summary>
        /// 同步接收对象
        /// </summary>
        private class ReceiveObject : IDisposable
        {
            public Socket Client;
            public byte[] Buffer = new byte[4096];
            public System.IO.MemoryStream Stream = new System.IO.MemoryStream();
            public System.Threading.ManualResetEvent ReceiveDone = new System.Threading.ManualResetEvent(false);

            public void Dispose()
            {
                this.Stream.Close();
            }
        }

        /// <summary>
        /// read回调
        /// </summary>
        /// <param name="ar"></param>
        private static void ReadCallback(IAsyncResult ar)
        {
            ReceiveObject state = (ReceiveObject)ar.AsyncState;
            int bytesRead = state.Client.EndReceive(ar);
            if (bytesRead > 0)
            {
                try
                {
                    state.Stream.Write(state.Buffer, 0, bytesRead);
                    state.Client.BeginReceive(state.Buffer, 0, state.Buffer.Length, SocketFlags.None, new AsyncCallback(ReadCallback), state);
                }
                catch (Exception ex)
                {
                    Log.Error(ex.Message);
                    state.ReceiveDone.Set();
                }
            }
            else
            {
                state.ReceiveDone.Set();
                // state.Client.EndReceive(ar);
            }
        }
        #endregion
    }