public void Set(ClientUID client_uid, ushort header, ByteArray by)
 {
     data.WriteUShort(header);  //必须填入id
     client_uid.Write(data);
     by.Skip(ClientUID.Size()); //由于by是C2S消息,带ClientUID,所以跳过
     by.Read(data, by.Available);
 }
        /// <summary>
        /// 发送由gate转发给client的消息
        /// </summary>
        /// <param name="conn_idx"></param>
        /// <param name="header"></param>
        /// <param name="by"></param>
        /// <returns></returns>
        public int SendProxy(long conn_idx, ushort header, ByteArray by)
        {
            int size = 0;

            if (m_net_socket != null)
            {
                m_send_by.Clear();
                m_send_by.WriteUShort(0);         //先写入长度占位
                m_send_by.WriteUShort(header);    //协议头
                by.Read(m_send_by, by.Available); //协议内容
                size = m_net_socket.Send(conn_idx, m_send_by);
            }
            return(size);
        }
Exemple #3
0
 protected void ParsePacket()
 {
     while (m_by_buffer.Available >= NetID.PacketHeadSize)
     {
         if (m_by_buffer.Peek(ref head_by, NetID.PacketHeadSize))
         {
             ushort msg_length = BitConverter.ToUInt16(head_by, 0);
             if (m_by_buffer.Available >= msg_length + NetID.PacketHeadSize)
             {
                 //读取包数据
                 m_by_buffer.Skip(NetID.PacketHeadSize);
                 ushort header = m_by_buffer.ReadUShort();
                 m_dispatcher_buffer.Clear();
                 int len = m_by_buffer.Read(m_dispatcher_buffer, msg_length - sizeof(ushort));
                 if (len != msg_length - sizeof(ushort))
                 {
                     Log.Error("读取错误");
                     m_by_buffer.Skip(msg_length - sizeof(ushort));//跳到下一个位置
                     continue;
                 }
                 //派发数据
                 if (m_net_socket != null && m_net_socket.OnReceive != null)
                 {
                     m_net_socket.OnReceive(m_conn_idx, header, m_dispatcher_buffer);
                 }
             }
             else
             {
                 break;
             }
         }
         else
         {
             break;
         }
     }
 }
        /// <summary>
        /// 显示查询结果
        /// </summary>
        private void ShowQueryResult(QueryInfo query_info, ByteArray by)
        {
            if (by.Available == 0)
            {
                m_query_info = null;
                MessageBox.Show("查询数据为空", "信息", MessageBoxButtons.OK);
                return;
            }
            m_query_info = query_info;

            int total_length_one_row = 0;

            foreach (var bin_header in m_list_bin_header)
            {
                switch (bin_header.type)
                {
                case "int":
                case "uint":
                    total_length_one_row += bin_header.length;
                    break;

                case "float": total_length_one_row += 4; break;

                case "double": total_length_one_row += 8; break;

                case "string": /**undo*/; break;

                default: continue;
                }
            }

            ///解析
            m_list_bin_contentes.Clear();
            while (by.Available > 0)
            {
                if ((query_info.fixed_length > 0 && by.Available < query_info.fixed_length) || (by.Available < total_length_one_row))
                {
                    MessageBox.Show("数据异常,长度不够", "警告", MessageBoxButtons.OK);
                    break;
                }

                int start_pos = by.Head;

                List <BinContent> list = new List <BinContent>();
                foreach (var bin_header in m_list_bin_header)
                {
                    string value  = "";
                    byte[] by_val = new byte[8];
                    switch (bin_header.type)
                    {
                    case "int": by.Read(ref by_val, bin_header.length); value = BitConverter.ToInt64(by_val, 0).ToString(); break;

                    case "uint": by.Read(ref by_val, bin_header.length); value = BitConverter.ToUInt64(by_val, 0).ToString(); break;

                    case "float": value = by.ReadFloat().ToString(); break;

                    case "double": value = by.ReadDouble().ToString(); break;

                    case "string": value = by.ReadString(); break;

                    default: continue;
                    }
                    list.Add(new BinContent(bin_header.type, value));
                }
                m_list_bin_contentes.Add(list);

                if (query_info.fixed_length > 0)
                {
                    by.SetHead(start_pos + query_info.fixed_length);
                }
            }

            ///显示数据
            m_find_result.Rows.Clear();
            for (int row = 0; row < m_list_bin_contentes.Count; ++row)
            {
                int index = this.m_find_result.Rows.Add();
                List <BinContent> list = m_list_bin_contentes[row];
                for (int col = 0; col < list.Count; col++)
                {
                    m_find_result.Rows[index].Cells[col].Value = list[col].value;
                }
            }
        }
 public override void Read(ByteArray by)
 {
     base.Read(by);
     by.Read(data, by.Available);
 }
 public override void Read(ByteArray by)
 {
     base.Read(by);
     is_broadcast = by.ReadBool();
     by.Read(data, by.Available);
 }