Esempio n. 1
0
        public static byte[] SerializeData(object[] data)
        {
            netvrkType[]  type     = new netvrkType[data.Length];
            List <byte[]> buffer   = new List <byte[]>();
            string        typeName = "null";
            int           byteSize = 0;

            for (int i = 0; i < data.Length; i++)
            {
                type[i] = netvrkType.None;
                byte[] tmpBuffer;

                if (data[i] != null)
                {
                    typeName = data[i].GetType().Name;
                }

                switch (typeName)
                {
                case "Byte":
                    type[i]   = netvrkType.Byte;
                    tmpBuffer = BitConverter.GetBytes((byte)data[i]);
                    break;

                case "Boolean":
                    type[i]   = netvrkType.Bool;
                    tmpBuffer = BitConverter.GetBytes((bool)data[i]);
                    break;

                case "Int16":
                    type[i]   = netvrkType.Short;
                    tmpBuffer = BitConverter.GetBytes((short)data[i]);
                    break;

                case "UInt16":
                    type[i]   = netvrkType.UShort;
                    tmpBuffer = BitConverter.GetBytes((ushort)data[i]);
                    break;

                case "Int32":
                    type[i]   = netvrkType.Int;
                    tmpBuffer = BitConverter.GetBytes((int)data[i]);
                    break;

                case "UInt32":
                    type[i]   = netvrkType.UInt;
                    tmpBuffer = BitConverter.GetBytes((uint)data[i]);
                    break;

                case "Int64":
                    type[i]   = netvrkType.Long;
                    tmpBuffer = BitConverter.GetBytes((long)data[i]);
                    break;

                case "UInt64":
                    type[i]   = netvrkType.ULong;
                    tmpBuffer = BitConverter.GetBytes((ulong)data[i]);
                    break;

                case "Single":
                    type[i]   = netvrkType.Float;
                    tmpBuffer = BitConverter.GetBytes((float)data[i]);
                    break;

                case "Double":
                    type[i]   = netvrkType.Double;
                    tmpBuffer = BitConverter.GetBytes((double)data[i]);
                    break;

                case "String":
                    type[i] = netvrkType.String;
                    string myString = (string)(data[i]);
                    int    len      = Encoding.UTF8.GetByteCount(myString);
                    tmpBuffer = new byte[len + 2];
                    Buffer.BlockCopy(BitConverter.GetBytes((short)len), 0, tmpBuffer, 0, 2);
                    Encoding.UTF8.GetBytes(myString, 0, myString.Length, tmpBuffer, 2);
                    break;

                case "Vector2":
                    type[i]   = netvrkType.Vector2;
                    tmpBuffer = SerializeVector2((Vector2)data[i]);
                    break;

                case "Vector3":
                    type[i]   = netvrkType.Vector3;
                    tmpBuffer = SerializeVector3((Vector3)data[i]);
                    break;

                case "Vector4":
                    type[i]   = netvrkType.Vector4;
                    tmpBuffer = SerializeVector4((Vector4)data[i]);
                    break;

                case "Quaternion":
                    type[i]   = netvrkType.Quaternion;
                    tmpBuffer = SerializeQuaternion((Quaternion)data[i]);
                    break;

                case "Byte[]":
                    type[i] = netvrkType.ByteArray;
                    short len2 = (short)((byte[])data[i]).Length;
                    tmpBuffer = new byte[len2 + 2];
                    Buffer.BlockCopy(BitConverter.GetBytes(len2), 0, tmpBuffer, 0, 2);
                    Buffer.BlockCopy((byte[])data[i], 0, tmpBuffer, 2, len2);
                    break;

                case "Color":
                    type[i]   = netvrkType.Color;
                    tmpBuffer = SerializeColor((Color)data[i]);
                    break;

                case "Color32":
                    type[i]   = netvrkType.Color32;
                    tmpBuffer = SerializeColor32((Color32)data[i]);
                    break;

                default:
                    tmpBuffer = new byte[0];
                    break;
                }
                buffer.Add(tmpBuffer);
                byteSize += tmpBuffer.Length + 1;
            }

            byte[] bytes = new byte[byteSize];

            using (MemoryStream memoryStream = new MemoryStream(bytes))
            {
                BinaryWriter bw = new BinaryWriter(memoryStream);
                for (int i = 0; i < data.Length; i++)
                {
                    bw.Write((byte)type[i]);
                    bw.Write(buffer[i]);
                }
            }
            return(bytes);
        }
Esempio n. 2
0
        public static object[] UnserializeData(byte[] buffer)
        {
            int           i    = 0;
            List <object> data = new List <object>();

            using (MemoryStream memoryStream = new MemoryStream(buffer))
            {
                BinaryReader br = new BinaryReader(memoryStream);
                while (memoryStream.Position < memoryStream.Length)
                {
                    netvrkType type    = (netvrkType)br.ReadByte();
                    object     tmpData = null;

                    switch (type)
                    {
                    case netvrkType.Byte:
                        tmpData = br.ReadByte();
                        break;

                    case netvrkType.Bool:
                        tmpData = br.ReadBoolean();
                        break;

                    case netvrkType.Short:
                        tmpData = br.ReadInt16();
                        break;

                    case netvrkType.UShort:
                        tmpData = br.ReadUInt16();
                        break;

                    case netvrkType.Int:
                        tmpData = br.ReadInt32();
                        break;

                    case netvrkType.UInt:
                        tmpData = br.ReadUInt32();
                        break;

                    case netvrkType.Long:
                        tmpData = br.ReadInt64();
                        break;

                    case netvrkType.ULong:
                        tmpData = br.ReadUInt64();
                        break;

                    case netvrkType.Float:
                        tmpData = br.ReadSingle();
                        break;

                    case netvrkType.Double:
                        tmpData = br.ReadDouble();
                        break;

                    case netvrkType.String:
                        short  len       = br.ReadInt16();
                        byte[] tmpBuffer = br.ReadBytes(len);
                        tmpData = Encoding.UTF8.GetString(tmpBuffer);
                        break;

                    case netvrkType.None:
                        break;

                    case netvrkType.Vector2:
                        tmpData = DeserializeVector2(br.ReadBytes(8));
                        break;

                    case netvrkType.Vector3:
                        tmpData = DeserializeVector3(br.ReadBytes(12));
                        break;

                    case netvrkType.Vector4:
                        tmpData = DeserializeVector4(br.ReadBytes(16));
                        break;

                    case netvrkType.Quaternion:
                        tmpData = DeserializeQuaternion(br.ReadBytes(16));
                        break;

                    case netvrkType.Color:
                        tmpData = DeserializeColor(br.ReadBytes(12));
                        break;

                    case netvrkType.Color32:
                        tmpData = DeserializeColor32(br.ReadBytes(16));
                        break;

                    case netvrkType.ByteArray:
                        short len2 = br.ReadInt16();
                        tmpData = br.ReadBytes((int)len2);
                        break;
                    }
                    i++;
                    data.Add(tmpData);
                }
            }
            return(data.ToArray());
        }