/// <summary> /// Generates IL to read a single item from the stream and leaves the result on the stack. /// </summary> /// <param name="type">The <see cref="Type"/> of item to read.</param> /// <param name="args">The arguments for generating the il.</param> void GenerateReadTypeIL(Type type, GenerateArgs args) { MethodInfo method = GetTypeMethod(type, TypeMethodType.Deserialize); DynamicMethodHelper il = args.il; bool dynamic = IsDynamic && (type.IsValueType == false); // Variable names const string valueVar = "_readValue"; const string dynamicTypeIndexVar = "_typeIndex"; const string dynamicTypeVar = "_dynamicType"; const string dynamicTypeNameVar = "_dynamicTypeName"; const string dynamicTypeResolvedLabel = "_dynamicTypeResolved"; const string dynamicTypeNotNullLabel = "_dynamicTypeNotNull"; const string dynamicTypeDoneLabel = "_dynamicTypeDone"; il.BeginScope(); { if (dynamic) { il.DeclareLocal(dynamicTypeIndexVar, typeof(byte)); il.DeclareLocal(valueVar, typeof(object)); il.DeclareLocal(dynamicTypeNameVar, typeof(string)); il.DeclareLocal(dynamicTypeVar, typeof(Type)); // Read type index il.PushLocal(args.streamVar); il.CallMethod(GetTypeMethod(typeof(byte), TypeMethodType.Deserialize)); il.PopLocal(dynamicTypeIndexVar); // if (typeIndex == -1) goto :dynamicInstanceNull il.PushLocal(dynamicTypeIndexVar); il.PushInt(SerializerHeaders.NullVersion); il.GotoIfNotEqual(dynamicTypeNotNullLabel); // return null // goto :dynamicTypeDone il.PushNull(); il.Goto(dynamicTypeDoneLabel); // :dynamicTypeNotNull il.MarkLabel(dynamicTypeNotNullLabel); // Get type info for typeIndex il.PushLocal(args.nameTableVar); il.PushLocal(dynamicTypeIndexVar); il.PushLocalAsRef(dynamicTypeVar); il.PushLocalAsRef(dynamicTypeNameVar); il.CallMethod(typeof(TypeNameTable).GetMethod("GetTypeInfo")); // If (type != null) goto :typeResolved il.PushLocal(dynamicTypeVar); il.GotoIfTrue(dynamicTypeResolvedLabel); // Call Type.GetType to resolve type. We must do this // in the context of the type being deserialized to // get the appropriate visibility permissions il.PushLocal(dynamicTypeNameVar); il.PushBool(true); il.CallMethod(typeof(Type).GetMethod( "GetType", BindingFlags.Static | BindingFlags.Public, null, new [] { typeof(string), typeof(bool) }, null )); il.PopLocal(dynamicTypeVar); // Save the resolved type back to the type table so // subsequent instances of the same type don't have to // do it again il.PushLocal(args.nameTableVar); il.PushLocal(dynamicTypeIndexVar); il.PushLocal(dynamicTypeVar); il.CallMethod(typeof(TypeNameTable).GetMethod("SetResolvedType")); // :typeResolved il.MarkLabel(dynamicTypeResolvedLabel); // Create an empty instance of the resolved type il.PushLocal(dynamicTypeVar); il.PushBool(true); il.CallMethod(typeof(Activator).GetMethod( "CreateInstance", new [] { typeof(Type), typeof(bool) } )); il.PopLocal(valueVar); // Call the serializer to read it il.PushLocalAsRef(valueVar); il.PushArg(args.dataArg); il.CallMethod(method); il.Pop(); // return (baseType)dynamicInstance il.PushLocal(valueVar); il.Cast(type); // :dynamicTypeDone il.MarkLabel(dynamicTypeDoneLabel); } else if (method.DeclaringType == typeof(IPrimitiveReader)) { // return reader.ReadXXXX() il.PushLocal(args.streamVar); il.CallMethod(method); } else //if (type.IsClass) { // Create empty instance of type il.DeclareLocal(valueVar, typeof(object)); if (type.IsClass) { il.NewObject(valueVar, type, Type.EmptyTypes); } // Call the serializer to read it il.PushLocalAsRef(valueVar); il.PushArg(args.dataArg); il.CallMethod(method); il.Pop(); // Ignore return value // return (type)instance il.PushLocal(valueVar); if (type.IsClass) { il.Cast(type); } else { il.UnboxValueType(type); } } } il.EndScope(); }
/// <summary> /// Generates IL to deserialize the property from a stream /// </summary> /// <param name="args"> /// <para>The arguments used to generate the read il.</para> /// </param> public void GenerateReadIL(GenerateArgs args) { #region Names const string loopStart = "loopStart"; const string loopEnd = "loopEnd"; const string propVar = "propValue"; const string elemVar = "elemVar"; const string indexVar = "loopIndex"; const string instanceVar = "instance"; const string countVar = "count"; const string collectionNotNull = "collectionNotNull"; const string skipObsoleteLabel = "skipObsolete"; #endregion DynamicMethodHelper il = args.il; if (this.attribute.ReadMethod != null) { // Call custom handler MethodInfo method = this.OwnerType.GetMethod( this.attribute.ReadMethod, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy, null, new [] { typeof(IPrimitiveReader) }, null ); if (method == null) { throw new ApplicationException(string.Format( "Failed to locate method {0}.{1} to read property {2}", this.OwnerType.Name, this.attribute.ReadMethod, this.Name )); } il.PushArg(args.instanceArg); il.PushLocal(args.streamVar); il.CallMethod(method); return; } il.DeclareLocal(instanceVar, this.OwnerType); il.DeclareLocal(propVar, this.Type); il.PushArg(args.instanceArg); il.PopLocal(instanceVar); // Create loop for collection types if (IsCollection) { il.DeclareLocal(indexVar, typeof(int)); il.DeclareLocal(countVar, typeof(int)); il.DeclareLocal(elemVar, this.elementType); // countVar = reader.ReadInt32() il.PushLocal(args.streamVar); il.CallMethod(GetTypeMethod(typeof(int), TypeMethodType.Deserialize)); il.PopLocal(countVar); // ; Set prop to null if length < 0 // if (countVar >= 0) goto collectionNotNull il.PushLocal(countVar); il.PushInt(0); il.GotoIfGreaterOrEqual(collectionNotNull); // propVar = null // goto loopEnd il.PushNull(); il.PopLocal(propVar); il.Goto(loopEnd); // :collectionNotNull // if (indexer) // propVar = instanceVar // else if (array) // propVar = new(countVar) // else // propVar = new() // end if il.MarkLabel(collectionNotNull); if (this.classType != null) { il.CopyLocal(instanceVar, propVar); } else if (IsArray) { il.PushLocal(countVar); il.NewObject(propVar, new [] { typeof(int) }); } else { il.NewObject(propVar); } // indexVar = 0 // :loopStart // if (indexVar == countVar) goto loopEnd il.PushInt(0); il.PopLocal(indexVar); il.MarkLabel(loopStart); il.PushLocal(indexVar); il.PushLocal(countVar); il.GotoIfEqual(loopEnd); } // If this is a dictionary then do special handling to add the element // If not then just read the value and use generic code to store it if (IsDictionary) { // propVar.Add(ReadKey(), ReadValue()) il.PushLocal(propVar); il.Cast(this.dictionaryInterfaceType); this.GenerateReadTypeIL(this.dictionaryKeyType, args); this.GenerateReadTypeIL(this.dictionaryValueType, args); il.CallMethod(this.collectionAddMethod); } else { GenerateReadTypeIL(this.elementType, args); il.PopLocal(IsCollection ? elemVar : propVar); } // If this is a collection then add the element and loop if (IsCollection) { switch (this.serializationType & PropertySerializationType.CollectionMask) { case PropertySerializationType.Dictionary: // Already handled break; case PropertySerializationType.Array: // push propValue ; arg 1 (this) // push loopIndex ; arg 2 // push elemValue ; arg 3 // call SetValue il.BeginCallMethod(propVar, "SetValue", new [] { typeof(object), typeof(int) }); il.PushLocalAsObject(elemVar); il.PushLocal(indexVar); il.CallMethod(); break; case PropertySerializationType.List: // push propValue ; arg 1 (this) // push elemValue ; arg 2 // call Add il.PushLocal(propVar); il.Cast(this.collectionInterfaceType); il.PushLocal(elemVar); il.CallMethod(this.collectionAddMethod); break; } // indexVar++ // goto loopStart // :loopEnd il.IncrementLocal(indexVar); il.Goto(loopStart); il.MarkLabel(loopEnd); } // Set property/field value // This isn't required for indexers. if (this.property != null) { if (this.property is PropertyInfo) { il.PushLocal(instanceVar); il.PushLocal(propVar); il.CallMethod(((PropertyInfo)this.property).GetSetMethod(true)); } else // FieldInfo { il.SetField(instanceVar, propVar, (FieldInfo)this.property); } } if (this.attribute.ObsoleteVersion > 0) { il.MarkLabel(skipObsoleteLabel); } }