Exemplo n.º 1
0
        void OnDataReceived()
        {
            UInt32 left = mnPacketSize;

            while (left >= ConstDefine.AF_PACKET_HEAD_SIZE)
            {
                object structType = new MsgHead();
                byte[] headBytes  = new byte[Marshal.SizeOf(structType)];

                Array.Copy(mPacket, mnPacketSize - left, headBytes, 0, Marshal.SizeOf(structType));
                StructureTransform.ByteArrayToStructureEndian(headBytes, ref structType, 0);
                MsgHead head = (MsgHead)structType;

                if (head.unDataLen >= left)
                {
                    byte[] body_head = new byte[head.unDataLen];
                    Array.Copy(mPacket, mnPacketSize - left, body_head, 0, head.unDataLen);
                    left -= head.unDataLen;
                    if (false == OnDataReceived(this, body_head, head.unDataLen))
                    {
                        OnClientDisconnect(new AFTCPEventParams());
                    }
                }
                else
                {
                    Array.Copy(mPacket, mnPacketSize - left, mPacket, 0, left);
                    break;
                }
            }
            mnPacketSize = left;
        }
Exemplo n.º 2
0
        bool OnDataReceived(AFClientNet client, byte[] bytes, UInt32 bytesCount)
        {
            if (bytes.Length == bytesCount)
            {
                object structType = new MsgHead();
                StructureTransform.ByteArrayToStructureEndian(bytes, ref structType, 0);
                MsgHead head = (MsgHead)structType;

                Int32 nBodyLen = (Int32)bytesCount - (Int32)ConstDefine.AF_PACKET_HEAD_SIZE;
                if (nBodyLen >= 0)
                {
                    byte[] body = new byte[nBodyLen];
                    Array.Copy(bytes, ConstDefine.AF_PACKET_HEAD_SIZE, body, 0, nBodyLen);

                    client.net.OnMessageEvent(head, body);
                    return(true);
                }
                else
                {
                }
            }

            return(false);
        }
Exemplo n.º 3
0
        public static byte[] StructureToByteArrayEndian(object obj)
        {
            object thisBoxed = obj;
            Type   test      = thisBoxed.GetType();

            int offset = 0;

            byte[] data = new byte[Marshal.SizeOf(thisBoxed)];

            object   fieldValue;
            TypeCode typeCode;

            byte[] temp;

            foreach (var field in test.GetFields())
            {
                fieldValue = field.GetValue(thisBoxed);            // Get value

                typeCode = Type.GetTypeCode(fieldValue.GetType()); // get type

                switch (typeCode)
                {
                case TypeCode.Single:     // float
                {
                    temp = BitConverter.GetBytes((Single)fieldValue);
                    StructureTransform.Reverse(temp);
                    Array.Copy(temp, 0, data, offset, sizeof(Single));
                    break;
                }

                case TypeCode.Int32:
                {
                    temp = BitConverter.GetBytes((Int32)fieldValue);
                    StructureTransform.Reverse(temp);
                    Array.Copy(temp, 0, data, offset, sizeof(Int32));
                    break;
                }

                case TypeCode.UInt32:
                {
                    temp = BitConverter.GetBytes((UInt32)fieldValue);
                    StructureTransform.Reverse(temp);
                    Array.Copy(temp, 0, data, offset, sizeof(UInt32));
                    break;
                }

                case TypeCode.Int16:
                {
                    temp = BitConverter.GetBytes((Int16)fieldValue);
                    StructureTransform.Reverse(temp);
                    Array.Copy(temp, 0, data, offset, sizeof(Int16));
                    break;
                }

                case TypeCode.UInt16:
                {
                    temp = BitConverter.GetBytes((UInt16)fieldValue);
                    StructureTransform.Reverse(temp);
                    Array.Copy(temp, 0, data, offset, sizeof(UInt16));
                    break;
                }

                case TypeCode.Int64:
                {
                    temp = BitConverter.GetBytes((Int64)fieldValue);
                    StructureTransform.Reverse(temp);
                    Array.Copy(temp, 0, data, offset, sizeof(Int64));
                    break;
                }

                case TypeCode.UInt64:
                {
                    temp = BitConverter.GetBytes((UInt64)fieldValue);
                    StructureTransform.Reverse(temp);
                    Array.Copy(temp, 0, data, offset, sizeof(UInt64));
                    break;
                }

                case TypeCode.Double:
                {
                    temp = BitConverter.GetBytes((Double)fieldValue);
                    StructureTransform.Reverse(temp);
                    Array.Copy(temp, 0, data, offset, sizeof(Double));
                    break;
                }

                case TypeCode.Byte:
                {
                    data[offset] = (Byte)fieldValue;
                    break;
                }

                default:
                {
                    //System.Diagnostics.Debug.Fail("No conversion provided for this type : " + typeCode.ToString());
                    break;
                }
                }
                ;  // switch
                if (typeCode == TypeCode.Object)
                {
                    int length = ((byte[])fieldValue).Length;
                    Array.Copy(((byte[])fieldValue), 0, data, offset, length);
                    offset += length;
                }
                else
                {
                    offset += Marshal.SizeOf(fieldValue);
                }
            } // foreach

            return(data);
        } // Swap