예제 #1
0
        private object DeserializeObject(object sourceValue, Type destinationType)
        {
            byte[]    buffer;
            Exception ex;

            if (!this.CanConvert(sourceValue, destinationType, out buffer, out ex))
            {
                throw ex;
            }
            object obj;

            using (MemoryStream memoryStream = new MemoryStream(buffer))
            {
                AppDomain.CurrentDomain.AssemblyResolve += SerializationTypeConverter.AssemblyHandler;
                try
                {
                    BinaryFormatter binaryFormatter = new BinaryFormatter();
                    obj = binaryFormatter.Deserialize(memoryStream);
                    IDeserializationCallback deserializationCallback = obj as IDeserializationCallback;
                    if (deserializationCallback != null)
                    {
                        deserializationCallback.OnDeserialization(sourceValue);
                    }
                }
                finally
                {
                    AppDomain.CurrentDomain.AssemblyResolve -= SerializationTypeConverter.AssemblyHandler;
                }
            }
            return(obj);
        }
        public void Deserialization()
        {
            TextInfo ti = CultureInfo.CurrentCulture.TextInfo;
            IDeserializationCallback dc = (ti as IDeserializationCallback);

            dc.OnDeserialization(null);
        }
예제 #3
0
        /// <summary>
        /// Runs when the entire object graph has been deserialized.
        /// </summary>
        /// <param name="sender">The object that initiated the callback. The functionality for this parameter is not currently implemented.</param>
        public void OnDeserialization(object sender)
        {
            IDeserializationCallback callback = dict as IDeserializationCallback;

            if (callback != null)
            {
                callback.OnDeserialization(sender);
            }
        }
예제 #4
0
        public void Interfaces()
        {
            WindowsIdentity id = WindowsIdentity.GetAnonymous();

            IIdentity i = (id as IIdentity);

            Assert.IsNotNull(i, "IIdentity");

            IDeserializationCallback dc = (id as IDeserializationCallback);

            Assert.IsNotNull(dc, "IDeserializationCallback");
            ISerializable s = (id as ISerializable);

            Assert.IsNotNull(s, "ISerializable");
        }
            object IObjectReference.GetRealObject(StreamingContext context)
            {
                ExtensionRegistry registry = context.Context as ExtensionRegistry;
                TBuilder          builder  = TemplateInstance.DefaultInstanceForType.CreateBuilderForType();

                builder.MergeFrom(_message, registry ?? ExtensionRegistry.Empty);

                IDeserializationCallback callback = builder as IDeserializationCallback;

                if (callback != null)
                {
                    callback.OnDeserialization(context);
                }

                return(builder);
            }
예제 #6
0
 public virtual void RaiseDeserializationEvent()
 {
     for (int i = _onDeserializedCallbackRecords.Count - 1; i >= 0; i--)
     {
         ObjectRecord record = (ObjectRecord)_onDeserializedCallbackRecords [i];
         RaiseOnDeserializedEvent(record.OriginalObject);
     }
     for (int i = _deserializedRecords.Count - 1; i >= 0; i--)
     {
         ObjectRecord             record = (ObjectRecord)_deserializedRecords [i];
         IDeserializationCallback obj    = record.OriginalObject as IDeserializationCallback;
         if (obj != null)
         {
             obj.OnDeserialization(this);
         }
     }
 }
예제 #7
0
        private object deserialize(XmlReader xmlReader, int id, SerializationInfo info, List <int> dimensionLengths, IFormatterConverter converter)
        {
            System.Diagnostics.Debug.Assert(null != xmlReader, "The 'xmlReader' argument cannot be null.");
            System.Diagnostics.Debug.Assert(null != info, "The 'info' argument cannot be null.");
            System.Diagnostics.Debug.Assert(null != converter, "The 'converter' argument cannot be null.");

            string assemblyQualifiedTypeName = string.Format("{0}, {1}", info.FullTypeName, info.AssemblyName);
            Type   objectType = new TypeParser().Resolve(assemblyQualifiedTypeName);

            object deserialized = null;             // Return value

            if (this.isSimpleType(objectType))
            {
                deserialized = this.readValue(xmlReader, objectType, converter);
            }
            else if (objectType.IsArray)
            {
                Type elementType = objectType.GetElementType();
                deserialized = this.deserializeArray(xmlReader, id, elementType, dimensionLengths, converter);
            }
            else
            {
                deserialized = this.deserializeObject(xmlReader, id, objectType, info, converter);
            }

            IObjectReference objectReference = deserialized as IObjectReference;

            if (null != objectReference)
            {
                deserialized = objectReference.GetRealObject(this.context);
            }

            IDeserializationCallback deserializationCallback = deserialized as IDeserializationCallback;

            if (null != deserializationCallback)
            {
                deserializationCallback.OnDeserialization(this);
            }

            if (XmlNodeType.EndElement == xmlReader.NodeType)
            {
                xmlReader.ReadEndElement();
            }

            return(deserialized);
        }
예제 #8
0
 /// <summary>Raises the deserialization event to any registered object that implements <see cref="T:System.Runtime.Serialization.IDeserializationCallback" />.</summary>
 public virtual void RaiseDeserializationEvent()
 {
     for (int i = this._onDeserializedCallbackRecords.Count - 1; i >= 0; i--)
     {
         ObjectRecord objectRecord = (ObjectRecord)this._onDeserializedCallbackRecords[i];
         this.RaiseOnDeserializedEvent(objectRecord.OriginalObject);
     }
     for (int j = this._deserializedRecords.Count - 1; j >= 0; j--)
     {
         ObjectRecord             objectRecord2           = (ObjectRecord)this._deserializedRecords[j];
         IDeserializationCallback deserializationCallback = objectRecord2.OriginalObject as IDeserializationCallback;
         if (deserializationCallback != null)
         {
             deserializationCallback.OnDeserialization(this);
         }
     }
 }
예제 #9
0
        public static object FromJson(Type type, string str)
        {
            object             t = JsonUtility.FromJson(str, type);
            ISupportInitialize iSupportInitialize = t as ISupportInitialize;

            if (iSupportInitialize != null)
            {
                iSupportInitialize.EndInit();
            }

            IDeserializationCallback deserializationCallback = t as IDeserializationCallback;

            if (deserializationCallback != null)
            {
                deserializationCallback.OnDeserialization(t);
            }
            return(t);
        }
예제 #10
0
        public static T FromJson <T>(string str)
        {
            T t = JsonUtility.FromJson <T>(str);
            ISupportInitialize iSupportInitialize = t as ISupportInitialize;

            if (iSupportInitialize != null)
            {
                iSupportInitialize.EndInit();
            }


            IDeserializationCallback deserializationCallback = t as IDeserializationCallback;

            if (deserializationCallback != null)
            {
                deserializationCallback.OnDeserialization(t);
            }
            return(t);
        }
예제 #11
0
        /// <summary>
        /// Deserializes a value of type <see cref="T" /> using a specified <see cref="IDataReader" />.
        /// </summary>
        /// <param name="reader">The reader to use.</param>
        /// <returns>
        /// The deserialized value.
        /// </returns>
        public T Deserialize(IDataReader reader)
        {
            var context = reader.Context;
            T   value   = this.GetUninitializedObject();

            // We allow the above method to return null (for reference types) because of special cases like arrays,
            //  where the size of the array cannot be known yet, and thus we cannot create an object instance at this time.
            //
            // Therefore, those who override GetUninitializedObject and return null must call RegisterReferenceID and InvokeOnDeserializingCallbacks manually.
            if (BaseFormatter <T> .IsValueType)
            {
                this.InvokeOnDeserializingCallbacks(ref value, context);
            }
            else
            {
                if (object.ReferenceEquals(value, null) == false)
                {
                    this.RegisterReferenceID(value, reader);
                    this.InvokeOnDeserializingCallbacks(ref value, context);

                    if (ImplementsIObjectReference)
                    {
                        try
                        {
                            value = (T)(value as IObjectReference).GetRealObject(context.StreamingContext);
                            this.RegisterReferenceID(value, reader);
                        }
                        catch (Exception ex)
                        {
                            context.Config.DebugContext.LogException(ex);
                        }
                    }
                }
            }

            try
            {
                this.DeserializeImplementation(ref value, reader);
            }
            catch (Exception ex)
            {
                context.Config.DebugContext.LogException(ex);
            }

            // The deserialized value might be null, so check for that
            if (BaseFormatter <T> .IsValueType || object.ReferenceEquals(value, null) == false)
            {
                for (int i = 0; i < OnDeserializedCallbacks.Length; i++)
                {
                    try
                    {
                        OnDeserializedCallbacks[i](ref value, context.StreamingContext);
                    }
                    catch (Exception ex)
                    {
                        context.Config.DebugContext.LogException(ex);
                    }
                }

                if (ImplementsIDeserializationCallback)
                {
                    IDeserializationCallback v = value as IDeserializationCallback;
                    v.OnDeserialization(this);
                    value = (T)v;
                }

                if (ImplementsISerializationCallbackReceiver)
                {
                    try
                    {
                        UnityEngine.ISerializationCallbackReceiver v = value as UnityEngine.ISerializationCallbackReceiver;
                        v.OnAfterDeserialize();
                        value = (T)v;
                    }
                    catch (Exception ex)
                    {
                        context.Config.DebugContext.LogException(ex);
                    }
                }
            }

            return(value);
        }
예제 #12
0
        object Unpack(MsgPackReader reader, Type t)
        {
            if (t.IsPrimitive)
            {
                if (!reader.Read())
                {
                    throw new FormatException();
                }
                if (t.Equals(typeof(int)) && reader.IsSigned())
                {
                    return(reader.ValueSigned);
                }
                else if (t.Equals(typeof(uint)) && reader.IsUnsigned())
                {
                    return(reader.ValueUnsigned);
                }
                else if (t.Equals(typeof(float)) && reader.Type == TypePrefixes.Float)
                {
                    return(reader.ValueFloat);
                }
                else if (t.Equals(typeof(double)) && reader.Type == TypePrefixes.Double)
                {
                    return(reader.ValueDouble);
                }
                else if (t.Equals(typeof(long)))
                {
                    if (reader.IsSigned64())
                    {
                        return(reader.ValueSigned64);
                    }
                    if (reader.IsSigned())
                    {
                        return((long)reader.ValueSigned);
                    }
                }
                else if (t.Equals(typeof(ulong)))
                {
                    if (reader.IsUnsigned64())
                    {
                        return(reader.ValueUnsigned64);
                    }
                    if (reader.IsUnsigned())
                    {
                        return((ulong)reader.ValueUnsigned);
                    }
                }
                else if (t.Equals(typeof(bool)) && reader.IsBoolean())
                {
                    return(reader.Type == TypePrefixes.True);
                }
                else if (t.Equals(typeof(byte)) && reader.IsUnsigned())
                {
                    return((byte)reader.ValueUnsigned);
                }
                else if (t.Equals(typeof(sbyte)) && reader.IsSigned())
                {
                    return((sbyte)reader.ValueSigned);
                }
                else if (t.Equals(typeof(short)) && reader.IsSigned())
                {
                    return((short)reader.ValueSigned);
                }
                else if (t.Equals(typeof(ushort)) && reader.IsUnsigned())
                {
                    return((ushort)reader.ValueUnsigned);
                }
                else if (t.Equals(typeof(char)) && reader.IsUnsigned())
                {
                    return((char)reader.ValueUnsigned);
                }
                else
                {
                    throw new NotSupportedException();
                }
            }

            UnpackDelegate unpacker;

            if (UnpackerMapping.TryGetValue(t, out unpacker))
            {
                return(unpacker(this, reader));
            }

            if (t.IsArray)
            {
                if (!reader.Read() || (!reader.IsArray() && reader.Type != TypePrefixes.Nil))
                {
                    throw new FormatException();
                }
                if (reader.Type == TypePrefixes.Nil)
                {
                    return(null);
                }
                Type  et  = t.GetElementType();
                Array ary = Array.CreateInstance(et, (int)reader.Length);
                for (int i = 0; i < ary.Length; i++)
                {
                    ary.SetValue(Unpack(reader, et), i);
                }
                return(ary);
            }

            if (!reader.Read())
            {
                throw new FormatException();
            }
            if (reader.Type == TypePrefixes.Nil)
            {
                return(null);
            }
            if (t.IsInterface)
            {
                if (reader.Type != TypePrefixes.FixArray && reader.Length != 2)
                {
                    throw new FormatException();
                }
                if (!reader.Read() || !reader.IsRaw())
                {
                    throw new FormatException();
                }
                CheckBufferSize((int)reader.Length);
                reader.ReadValueRaw(_buf, 0, (int)reader.Length);
                t = Type.GetType(Encoding.UTF8.GetString(_buf, 0, (int)reader.Length));
                if (!reader.Read() || reader.Type == TypePrefixes.Nil)
                {
                    throw new FormatException();
                }
            }
            if (!reader.IsMap())
            {
                throw new FormatException();
            }

            object o = FormatterServices.GetUninitializedObject(t);
            ReflectionCacheEntry entry = ReflectionCache.Lookup(t);
            int members = (int)reader.Length;

            for (int i = 0; i < members; i++)
            {
                if (!reader.Read() || !reader.IsRaw())
                {
                    throw new FormatException();
                }
                CheckBufferSize((int)reader.Length);
                reader.ReadValueRaw(_buf, 0, (int)reader.Length);
                string    name = Encoding.UTF8.GetString(_buf, 0, (int)reader.Length);
                FieldInfo f;
                if (!entry.FieldMap.TryGetValue(name, out f))
                {
                    throw new FormatException();
                }
                f.SetValue(o, Unpack(reader, f.FieldType));
            }

            IDeserializationCallback callback = o as IDeserializationCallback;

            if (callback != null)
            {
                callback.OnDeserialization(this);
            }
            return(o);
        }
예제 #13
0
        public void RegisterObject(object obj, long objectID, SerializationInfo info, long idOfContainingObj, MemberInfo member, int[] arrayIndex)
        {
            ISerializationSurrogate surrogate = null;

            if (obj == null)
            {
                throw new ArgumentNullException("obj");
            }
            if (objectID <= 0L)
            {
                throw new ArgumentOutOfRangeException("objectID", Environment.GetResourceString("ArgumentOutOfRange_ObjectID"));
            }
            if (((member != null) && !(member is RuntimeFieldInfo)) && !(member is SerializationFieldInfo))
            {
                throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMemberInfo"));
            }
            if (this.m_selector != null)
            {
                ISurrogateSelector selector;
                Type type = null;
                if (this.CanCallGetType(obj))
                {
                    type = obj.GetType();
                }
                else
                {
                    type = typeof(MarshalByRefObject);
                }
                surrogate = this.m_selector.GetSurrogate(type, this.m_context, out selector);
            }
            if (obj is IDeserializationCallback)
            {
                IDeserializationCallback    callback1 = (IDeserializationCallback)obj;
                DeserializationEventHandler handler   = new DeserializationEventHandler(callback1.OnDeserialization);
                this.AddOnDeserialization(handler);
            }
            if (arrayIndex != null)
            {
                arrayIndex = (int[])arrayIndex.Clone();
            }
            ObjectHolder holder = this.FindObjectHolder(objectID);

            if (holder == null)
            {
                holder = new ObjectHolder(obj, objectID, info, surrogate, idOfContainingObj, (FieldInfo)member, arrayIndex);
                this.AddObjectHolder(holder);
                if (holder.RequiresDelayedFixup)
                {
                    this.SpecialFixupObjects.Add(holder);
                }
                this.AddOnDeserialized(obj);
            }
            else
            {
                if (holder.ObjectValue != null)
                {
                    throw new SerializationException(Environment.GetResourceString("Serialization_RegisterTwice"));
                }
                holder.UpdateData(obj, info, surrogate, idOfContainingObj, (FieldInfo)member, arrayIndex, this);
                if (holder.DirectlyDependentObjects > 0)
                {
                    this.CompleteObject(holder, false);
                }
                if (holder.RequiresDelayedFixup)
                {
                    this.SpecialFixupObjects.Add(holder);
                }
                if (holder.CompletelyFixed)
                {
                    this.DoNewlyRegisteredObjectFixups(holder);
                    holder.DependentObjects = null;
                }
                if (holder.TotalDependentObjects > 0)
                {
                    this.AddOnDeserialized(obj);
                }
                else
                {
                    this.RaiseOnDeserializedEvent(obj);
                }
            }
        }
예제 #14
0
        public void OnDeserialization(object sender)
        {
            IDeserializationCallback callback = m_dictionaryTyped as IDeserializationCallback;

            callback.OnDeserialization(sender);
        }
예제 #15
0
        private object DeserializeObject(object sourceValue, Type destinationType)
        {
            Exception ex = null;

            byte[] array;
            string text;

            if (!this.CanConvert(sourceValue, destinationType, out array, out text, out ex))
            {
                throw ex;
            }
            ExTraceGlobals.SerializationTracer.TraceFunction <object, string>((long)this.GetHashCode(), "SerializationTypeConverter.DeserializeObject(); SerializationData.Length = {0}; ToStringValue = '{1}'", (array == null) ? "<null>" : array.Length, text);
            object obj = null;

            try
            {
                using (MemoryStream memoryStream = new MemoryStream(array))
                {
                    AppDomain.CurrentDomain.AssemblyResolve += SerializationTypeConverter.AssemblyHandler;
                    try
                    {
                        int tickCount = Environment.TickCount;
                        if (SerializationTypeConverter.IsRunningInRPSServerSide.Value)
                        {
                            if (SerializationTypeBinder.Instance == null)
                            {
                                throw new InvalidCastException("SerializationTypeBinder initialization failed.");
                            }
                            obj = TypedBinaryFormatter.DeserializeObject(memoryStream, SerializationTypeBinder.Instance);
                        }
                        else
                        {
                            BinaryFormatter binaryFormatter = ExchangeBinaryFormatterFactory.CreateBinaryFormatter(null, new string[]
                            {
                                "System.Management.Automation.PSObject",
                                "System.DelegateSerializationHolder"
                            });
                            obj = binaryFormatter.Deserialize(memoryStream);
                        }
                        ExTraceGlobals.SerializationTracer.TraceDebug <string, int>((long)this.GetHashCode(), "DeserializeObject of type {0} succeeded in {1} ms.", (obj != null) ? obj.GetType().Name : "null", Environment.TickCount - tickCount);
                        IDeserializationCallback deserializationCallback = obj as IDeserializationCallback;
                        if (deserializationCallback != null)
                        {
                            deserializationCallback.OnDeserialization(sourceValue);
                        }
                    }
                    finally
                    {
                        AppDomain.CurrentDomain.AssemblyResolve -= SerializationTypeConverter.AssemblyHandler;
                    }
                }
            }
            catch (SerializationException ex2)
            {
                ExTraceGlobals.SerializationTracer.TraceDebug <SerializationException>((long)this.GetHashCode(), "Deserialization Failed. Error = {0}", ex2);
                if (ValueConvertor.TryConvertValueFromString(text, destinationType, null, out obj, out ex))
                {
                    ExTraceGlobals.SerializationTracer.TraceDebug <SerializationException>((long)this.GetHashCode(), "String Conversion Succeeded.", ex2);
                }
                else
                {
                    ex = new InvalidCastException(string.Format("Deserialization fails due to one SerializationException: {0}", ex2.ToString()), ex2);
                }
            }
            catch (DataSourceTransientException ex3)
            {
                ex = new InvalidCastException(string.Format("Deserialization fails due to an DataSourceTransientException: {0}", ex3.ToString()), ex3);
            }
            if (ex is InvalidCastException)
            {
                throw ex;
            }
            return(obj);
        }
예제 #16
0
        /// <summary>
        /// Runs when the entire object graph has been deserialized.
        /// </summary>
        /// <param name="sender">The object that initiated the callback. The functionality for this parameter is not currently implemented.</param>
        public void OnDeserialization(object sender)
        {
            IDeserializationCallback callback = dict as IDeserializationCallback;

            callback.OnDeserialization(sender);
        }
예제 #17
0
        object Unpack(MsgPackReader reader, Type t)
        {
            if (t.IsPrimitive)
            {
                if (!reader.Read())
                {
                    throw new FormatException();
                }
                if (t.Equals(typeof(int)) && reader.IsSigned())
                {
                    return(reader.ValueSigned);
                }
                else if (t.Equals(typeof(uint)) && reader.IsUnsigned())
                {
                    return(reader.ValueUnsigned);
                }
                else if (t.Equals(typeof(float)) && reader.Type == TypePrefixes.Float)
                {
                    return(reader.ValueFloat);
                }
                else if (t.Equals(typeof(double)) && reader.Type == TypePrefixes.Double)
                {
                    return(reader.ValueDouble);
                }
                else if (t.Equals(typeof(long)))
                {
                    if (reader.IsSigned64())
                    {
                        return(reader.ValueSigned64);
                    }
                    if (reader.IsSigned())
                    {
                        return((long)reader.ValueSigned);
                    }
                }
                else if (t.Equals(typeof(ulong)))
                {
                    if (reader.IsUnsigned64())
                    {
                        return(reader.ValueUnsigned64);
                    }
                    if (reader.IsUnsigned())
                    {
                        return((ulong)reader.ValueUnsigned);
                    }
                }
                else if (t.Equals(typeof(bool)) && reader.IsBoolean())
                {
                    return(reader.Type == TypePrefixes.True);
                }
                else if (t.Equals(typeof(byte)) && reader.IsUnsigned())
                {
                    return((byte)reader.ValueUnsigned);
                }
                else if (t.Equals(typeof(sbyte)) && reader.IsSigned())
                {
                    return((sbyte)reader.ValueSigned);
                }
                else if (t.Equals(typeof(short)) && reader.IsSigned())
                {
                    return((short)reader.ValueSigned);
                }
                else if (t.Equals(typeof(ushort)) && reader.IsUnsigned())
                {
                    return((ushort)reader.ValueUnsigned);
                }
                else if (t.Equals(typeof(char)) && reader.IsUnsigned())
                {
                    return((char)reader.ValueUnsigned);
                }
                else
                {
                    throw new NotSupportedException();
                }
            }

            UnpackDelegate unpacker;

            if (UnpackerMapping.TryGetValue(t, out unpacker))
            {
                return(unpacker(this, reader));
            }

            if (typeof(Packable).IsAssignableFrom(t))
            {
                Packable p = Activator.CreateInstance(t) as Packable;
                return(p.Unpack(this, reader));
            }

            if (t.IsArray)
            {
                if (!reader.Read() || (!reader.IsArray() && reader.Type != TypePrefixes.Nil))
                {
                    throw new FormatException();
                }
                if (reader.Type == TypePrefixes.Nil)
                {
                    return(null);
                }
                Type  et  = t.GetElementType();
                Array ary = Array.CreateInstance(et, (int)reader.Length);
                for (int i = 0; i < ary.Length; i++)
                {
                    ary.SetValue(Unpack(reader, et), i);
                }
                return(ary);
            }

            // IEnumerable 型の場合
            // 現在は IList, ISet, IDictionary をサポート
            if (typeof(IEnumerable).IsAssignableFrom(t) && t.IsGenericType)
            {
                Type[] generics = t.GetGenericArguments();

                // IList 型の場合
                if (typeof(IList).IsAssignableFrom(t))
                {
                    if (!reader.Read() || (!reader.IsArray() && reader.Type != TypePrefixes.Nil))
                    {
                        throw new FormatException();
                    }
                    if (reader.Type == TypePrefixes.Nil)
                    {
                        return(null);
                    }

                    Type  et    = generics.Single();
                    int   count = (int)reader.Length;
                    Array ary   = Array.CreateInstance(et, count);

                    for (int i = 0; i < count; i++)
                    {
                        ary.SetValue(Unpack(reader, et), i);
                    }
                    return(Activator.CreateInstance(t, new object[] { ary }));
                }

                // ISet 型の場合
                var setType = typeof(ISet <>).MakeGenericType(generics[0]);
                if (setType.IsAssignableFrom(t))
                {
                    if (!reader.Read() || (!reader.IsArray() && reader.Type != TypePrefixes.Nil))
                    {
                        throw new FormatException();
                    }
                    if (reader.Type == TypePrefixes.Nil)
                    {
                        return(null);
                    }

                    Type et    = generics.Single();
                    int  count = (int)reader.Length;

                    Array ary = Array.CreateInstance(et, count);

                    for (int i = 0; i < count; i++)
                    {
                        ary.SetValue(Unpack(reader, et), i);
                    }
                    return(Activator.CreateInstance(t, new object[] { ary }));
                }

                if (typeof(IDictionary).IsAssignableFrom(t))
                {
                    if (!reader.Read() || (!reader.IsArray() && reader.Type != TypePrefixes.Nil))
                    {
                        throw new FormatException();
                    }
                    if (reader.Type == TypePrefixes.Nil)
                    {
                        return(null);
                    }

                    Type kt = generics[0];
                    Type vt = generics[1];

                    IDictionary dict  = (IDictionary)Activator.CreateInstance(t);
                    int         count = (int)reader.Length;

                    for (int i = 0; i < count; i++)
                    {
                        dict[Unpack(reader, kt)] = Unpack(reader, vt);
                    }
                    return(dict);
                }
            }

            if (!reader.Read())
            {
                throw new FormatException();
            }
            if (reader.Type == TypePrefixes.Nil)
            {
                return(null);
            }
            if (t.IsInterface)
            {
                if (reader.Type != TypePrefixes.FixArray && reader.Length != 2)
                {
                    throw new FormatException();
                }
                if (!reader.Read() || !reader.IsRaw())
                {
                    throw new FormatException();
                }
                CheckBufferSize((int)reader.Length);
                reader.ReadValueRaw(_buf, 0, (int)reader.Length);
                t = Type.GetType(Encoding.UTF8.GetString(_buf, 0, (int)reader.Length));
                if (!reader.Read() || reader.Type == TypePrefixes.Nil)
                {
                    throw new FormatException();
                }
            }
            if (!reader.IsMap())
            {
                throw new FormatException();
            }

            object o = FormatterServices.GetUninitializedObject(t);
            ReflectionCacheEntry entry = ReflectionCache.Lookup(t);
            int members = (int)reader.Length;

            for (int i = 0; i < members; i++)
            {
                if (!reader.Read() || !reader.IsRaw())
                {
                    throw new FormatException();
                }
                CheckBufferSize((int)reader.Length);
                reader.ReadValueRaw(_buf, 0, (int)reader.Length);
                string    name = Encoding.UTF8.GetString(_buf, 0, (int)reader.Length);
                FieldInfo f;

                if (!entry.FieldMap.TryGetValue(name, out f))
                {
                    throw new FormatException();
                }
                f.SetValue(o, Unpack(reader, f.FieldType));
            }

            IDeserializationCallback callback = o as IDeserializationCallback;

            if (callback != null)
            {
                callback.OnDeserialization(this);
            }
            return(o);
        }