public object Deserialize(byte[] data)
        {
            PayloadReader pr = new PayloadReader(data);
            ObjectTypes Id = (ObjectTypes)pr.ReadByte();

            switch (Id)
            {
                case ObjectTypes.Null: return null;
                case ObjectTypes.Other:
                {
                    BinaryFormatter bf = new BinaryFormatter();
                    bf.Binder = new DeserializationBinder();
                    return bf.Deserialize(new MemoryStream(pr.ReadBytes(pr.Length - pr.Position)));
                }
                case ObjectTypes.Byte: return pr.ReadByte();
                case ObjectTypes.Short: return pr.ReadShort();
                case ObjectTypes.UShort: return pr.ReadUShort();
                case ObjectTypes.Int: return pr.ReadInteger();
                case ObjectTypes.UINT: return pr.ReadUInteger();
                case ObjectTypes.Long: return pr.ReadLong();
                case ObjectTypes.Bool: return pr.ReadByte() == 1;
                case ObjectTypes.String: return pr.ReadString();
                case ObjectTypes.SolidBrush: return new SolidBrush(Color.FromArgb(pr.ReadByte(), pr.ReadByte(), pr.ReadByte(), pr.ReadByte()));
                case ObjectTypes.Rectangle: return new Rectangle(pr.ReadInteger(), pr.ReadInteger(), pr.ReadInteger(), pr.ReadInteger());
                case ObjectTypes.Size: return new Size(pr.ReadInteger(), pr.ReadInteger());
                case ObjectTypes.ByteArray: return pr.ReadBytes(pr.ReadInteger());
                case ObjectTypes.Bitmap:
                {
                    using (MemoryStream stream = new MemoryStream(pr.Buffer, pr.Position, pr.Length - pr.Position))
                    {
                        long oldPos = stream.Position;
                        Bitmap bmp = (Bitmap)Bitmap.FromStream(stream);
                        pr.Position += (int)(stream.Position - oldPos);
                        return bmp;
                    }
                }
                default: throw new Exception("Error deserializing");
            }
        }
Пример #2
0
        public IMessage DeCacheMessage(IMessage message, PayloadReader pr, ref bool isCached, ref IMessage CachedMessage, MessageHandler msgHandler)
        {
            lock (Messages)
            {
                uint Id = msgHandler.GetMessageId(message.GetType());
                isCached = pr.ReadBool();

                if (!Messages.TryGetValue(Id, out CachedMessage) && !isCached)
                {
                    CachedMessage = (IMessage)Activator.CreateInstance(message.GetType());
                    Messages.Add(Id, (IMessage)Activator.CreateInstance(message.GetType()));

                    FieldInfo[] _fields       = message.GetType().GetFields();
                    FieldInfo[] _cachedFields = CachedMessage.GetType().GetFields();

                    for (int i = 0; i < _fields.Length; i++)
                    {
                        //de-serialize objects
                        int oldPos = pr.Offset;
                        _fields[i].SetValue(message, pr.ReadObject());
                        pr.Offset = oldPos;
                        _fields[i].SetValue(Messages[Id], pr.ReadObject());
                    }
                    return(message);
                }

                FieldInfo[] fields      = message.GetType().GetFields();
                FieldInfo[] cacheFields = CachedMessage.GetType().GetFields();

                for (int i = 0; i < fields.Length; i++)
                {
                    MessageCacheType CacheType = (MessageCacheType)pr.ReadByte();
                    object           NewValue  = null;

                    switch (CacheType)
                    {
                    case MessageCacheType.Bool:
                    {
                        NewValue = pr.ReadBool();
                        break;
                    }

                    case MessageCacheType.Byte:
                    {
                        NewValue = pr.ReadByte();
                        break;
                    }

                    case MessageCacheType.ByteArray:
                    {
                        uint size = pr.ReadUInteger();
                        NewValue = pr.ReadBytes((int)size);
                        break;
                    }

                    case MessageCacheType.Decimal:
                    {
                        NewValue = pr.ReadDecimal();
                        break;
                    }

                    case MessageCacheType.Double:
                    {
                        NewValue = pr.ReadDouble();
                        break;
                    }

                    case MessageCacheType.Float:
                    {
                        NewValue = pr.ReadFloat();
                        break;
                    }

                    case MessageCacheType.Long:
                    {
                        NewValue = pr.ReadLong();
                        break;
                    }

                    case MessageCacheType.NULL:
                    {
                        NewValue = null;
                        break;
                    }

                    case MessageCacheType.OtherObject:
                    {
                        NewValue = pr.ReadObject();
                        break;
                    }

                    case MessageCacheType.Short:
                    {
                        NewValue = pr.ReadShort();
                        break;
                    }

                    case MessageCacheType.String:
                    {
                        NewValue = pr.ReadString();
                        break;
                    }

                    case MessageCacheType.Integer:
                    {
                        NewValue = pr.ReadInteger();
                        break;
                    }

                    case MessageCacheType.UInteger:
                    {
                        NewValue = pr.ReadUInteger();
                        break;
                    }

                    case MessageCacheType.ULong:
                    {
                        NewValue = pr.ReadULong();
                        break;
                    }

                    case MessageCacheType.UShort:
                    {
                        NewValue = pr.ReadUShort();
                        break;
                    }

                    case MessageCacheType.NotUpdated:
                    {
                        NewValue = cacheFields[i].GetValue(CachedMessage);
                        break;
                    }
                    }
                    fields[i].SetValue(message, NewValue);
                }
            }
            return(message);
        }