Beispiel #1
0
 /// <summary>
 /// 发送 Socket 数据包, 过长的 byte流 会被拆成多个包发送
 /// 包头的 PacketCount , ByteLength 等参数会视 bytes 长度被修改
 /// </summary>
 /// <param name="socket"></param>
 /// <param name="header"></param>
 /// <param name="bytes"></param>
 protected void SendBytes(Socket socket, HB32Header header, byte[] bytes)
 {
     header.PacketCount     = ((bytes.Length > 0 ? bytes.Length : 1) - 1) / (HB32Encoding.DataSize) + 1;
     header.TotalByteLength = bytes.Length;
     header.PacketIndex     = 0;
     for (int offset = 0; offset < bytes.Length || offset == 0; offset += HB32Encoding.DataSize)
     {
         if (bytes.Length - offset < HB32Encoding.DataSize)
         {
             header.ValidByteLength = bytes.Length - offset;
             byte[] _toSend = new byte[HB32Encoding.PacketSize];
             Array.Copy(GetHeaderBytesFunc(header), 0, _toSend, 0, HB32Encoding.HeaderSize);
             Array.Copy(bytes, offset, _toSend, HB32Encoding.HeaderSize, bytes.Length - offset);
             socket.Send(_toSend);
         }
         else
         {
             header.ValidByteLength = HB32Encoding.DataSize;
             byte[] _toSend = new byte[HB32Encoding.PacketSize];
             Array.Copy(GetHeaderBytesFunc(header), 0, _toSend, 0, HB32Encoding.HeaderSize);
             Array.Copy(bytes, offset, _toSend, HB32Encoding.HeaderSize, HB32Encoding.DataSize);
             socket.Send(_toSend);
         }
         /// 若当前数据包之后还有数据包, 在等待对方 发送StreamRequest包头 后发送
         if (offset + HB32Encoding.DataSize < bytes.Length)
         {
             ReceiveHeader(socket, out _);
         }
         header.PacketIndex++;
     }
 }
Beispiel #2
0
 /// <summary>
 /// Send socket 只发送包头
 /// 只有 SendHeader() 会只发送包头
 /// SendBytes() 至少会发一个空包
 /// </summary>
 /// <param name="socket"></param>
 /// <param name="header"></param>
 protected void SendHeader(Socket socket, HB32Header header)
 {
     header.PacketCount     = 0;
     header.TotalByteLength = 0;
     header.PacketIndex     = 0;
     header.ValidByteLength = 0;
     socket.Send(GetHeaderBytesFunc(header), HB32Encoding.HeaderSize, SocketFlags.None);
 }
Beispiel #3
0
        /// 接收 Socket 数据包, 在接收不定长byte流时使用, 过长byte流会分开接收并拼接成byte数组
        /// 收到的数据只有包头时, 返回空byte数组
        protected void ReceiveBytes(Socket socket, out HB32Header header, out byte[] bytes)
        {
            /// 通过包头判断byte流长度, 确定byte数组大小 包数量 等基本信息
            ReceiveHeader(socket, out header);
            /// 此时 socket 只接收了HB32Header包头长度的字节
            /// 对于 SendHeader() 只发送包头的数据
            /// 函数会直接返回空byte数组

            /*
             * if (header.Flag == SocketPacketFlag.DownloadPacketRequest ||
             *  header.Flag == SocketPacketFlag.UploadPacketResponse)
             * {
             *  bytes = new byte[0];
             *  return;
             * }
             */
            bytes = new byte[header.TotalByteLength];
            int offset = 0;     // bytes 数组写入起点偏移量

            for (int i = 0; i < header.PacketCount; ++i)
            {
                if (i == header.PacketCount - 1)
                {
                    /// 读取缓冲区中有效数据
                    if (header.ValidByteLength > 0)
                    {
                        ReceiveBuffer(socket, bytes, header.ValidByteLength, offset);
                    }
                    /// 读取缓冲区中剩余的无效数据
                    ReceiveBuffer(socket, new byte[HB32Encoding.DataSize - header.ValidByteLength]);
                }
                else
                {
                    /// 读取缓冲区数据
                    ReceiveBuffer(socket, bytes, header.ValidByteLength, offset);
                    offset += header.ValidByteLength;
                    /// 发送 StreamRequset header
                    SendHeader(socket, SocketPacketFlag.StreamRequest);
                    /// 读取下一个包头
                    ReceiveHeader(socket, out header);
                }
            }
        }
Beispiel #4
0
 public static byte[] GetBytes(HB32Header header)
 {
     return(header.GetBytes());
 }
Beispiel #5
0
 /// <summary>
 /// 尽量不要用, 可以用 ReceiveBytes() 代替
 /// Receive Socket 数据包, 在确定接收数据包只有一个时使用, 输出 包头 和 byte数组格式内容
 /// </summary>
 /// <param name="socket"></param>
 /// <param name="header">输出包头</param>
 /// <param name="bytes_data"></param>
 protected void ReceivePacket(Socket socket, out HB32Header header, out byte[] bytes_data)
 {
     ReceiveHeader(socket, out header);
     bytes_data = new byte[HB32Encoding.DataSize];
     ReceiveBuffer(socket, bytes_data);
 }
Beispiel #6
0
 /// <summary>
 /// Receive socket 只接收包头
 /// </summary>
 /// <param name="socket"></param>
 /// <param name="header"></param>
 protected void ReceiveHeader(Socket socket, out HB32Header header)
 {
     byte[] bytes_header = new byte[HB32Encoding.HeaderSize];
     ReceiveBuffer(socket, bytes_header);
     header = HB32Header.ReadFromBytes(bytes_header);
 }
Beispiel #7
0
 /// <summary>
 /// 发送 Socket 数据包, 字符串以 UTF-8 编码后发送
 /// </summary>
 /// <param name="socket"></param>
 /// <param name="header"></param>
 /// <param name="str"></param>
 protected void SendBytes(Socket socket, HB32Header header, string str)
 {
     SendBytes(socket, header, Encoding.UTF8.GetBytes(str));
 }