WriteLiteralStructMethod()

void System.Xml.Serialization.XmlSerializationReaderILGen.WriteLiteralStructMethod ( StructMapping structMapping )

inlineprivate

Definition at line 1125 of file XmlSerializationReaderILGen.cs.

    {
        base.MethodNames.TryGetValue(structMapping, out var value);
        string cSharpName = structMapping.TypeDesc.CSharpName;
        ilg = new CodeGenerator(typeBuilder);
        List<Type> list = new List<Type>();
        List<string> list2 = new List<string>();
        if (structMapping.TypeDesc.IsNullable)
        {
            list.Add(typeof(bool));
            list2.Add("isNullable");
        }
        list.Add(typeof(bool));
        list2.Add("checkType");
        ilg.BeginMethod(structMapping.TypeDesc.Type, GetMethodBuilder(value), list.ToArray(), list2.ToArray(), MethodAttributes.Private | MethodAttributes.HideBySig);
        LocalBuilder localBuilder = ilg.DeclareLocal(typeof(XmlQualifiedName), "xsiType");
        LocalBuilder localBuilder2 = ilg.DeclareLocal(typeof(bool), "isNull");
        MethodInfo method = typeof(XmlSerializationReader).GetMethod("GetXsiType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
        MethodInfo method2 = typeof(XmlSerializationReader).GetMethod("ReadNull", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
        Label label = ilg.DefineLabel();
        Label label2 = ilg.DefineLabel();
        ilg.Ldarg("checkType");
        ilg.Brtrue(label);
        ilg.Load(null);
        ilg.Br_S(label2);
        ilg.MarkLabel(label);
        ilg.Ldarg(0);
        ilg.Call(method);
        ilg.MarkLabel(label2);
        ilg.Stloc(localBuilder);
        ilg.Ldc(boolVar: false);
        ilg.Stloc(localBuilder2);
        if (structMapping.TypeDesc.IsNullable)
        {
            ilg.Ldarg("isNullable");
            ilg.If();
            ilg.Ldarg(0);
            ilg.Call(method2);
            ilg.Stloc(localBuilder2);
            ilg.EndIf();
        }
        ilg.Ldarg("checkType");
        ilg.If();
        if (structMapping.TypeDesc.IsRoot)
        {
            ilg.Ldloc(localBuilder2);
            ilg.If();
            ilg.Ldloc(localBuilder);
            ilg.Load(null);
            ilg.If(Cmp.NotEqualTo);
            MethodInfo method3 = typeof(XmlSerializationReader).GetMethod("ReadTypedNull", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, new Type[1] { localBuilder.LocalType });
            ilg.Ldarg(0);
            ilg.Ldloc(localBuilder);
            ilg.Call(method3);
            ilg.Stloc(ilg.ReturnLocal);
            ilg.Br(ilg.ReturnLabel);
            ilg.Else();
            if (structMapping.TypeDesc.IsValueType)
            {
                throw Globals.NotSupported(System.SR.Arg_NeverValueType);
            }
            ilg.Load(null);
            ilg.Stloc(ilg.ReturnLocal);
            ilg.Br(ilg.ReturnLabel);
            ilg.EndIf();
            ilg.EndIf();
        }
        ilg.Ldloc(typeof(XmlQualifiedName), "xsiType");
        ilg.Load(null);
        ilg.Ceq();
        if (!structMapping.TypeDesc.IsRoot)
        {
            label = ilg.DefineLabel();
            label2 = ilg.DefineLabel();
            ilg.Brtrue(label);
            WriteQNameEqual("xsiType", structMapping.TypeName, structMapping.Namespace);
            ilg.Br_S(label2);
            ilg.MarkLabel(label);
            ilg.Ldc(boolVar: true);
            ilg.MarkLabel(label2);
        }
        ilg.If();
        if (structMapping.TypeDesc.IsRoot)
        {
            ConstructorInfo constructor = typeof(XmlQualifiedName).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, new Type[2]
            {
                typeof(string),
                typeof(string)
            });
            MethodInfo method4 = typeof(XmlSerializationReader).GetMethod("ReadTypedPrimitive", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, new Type[1] { typeof(XmlQualifiedName) });
            ilg.Ldarg(0);
            ilg.Ldstr("anyType");
            ilg.Ldstr("http://www.w3.org/2001/XMLSchema");
            ilg.New(constructor);
            ilg.Call(method4);
            ilg.Stloc(ilg.ReturnLocal);
            ilg.Br(ilg.ReturnLabel);
        }
        WriteDerivedTypes(structMapping, !structMapping.TypeDesc.IsRoot, cSharpName);
        if (structMapping.TypeDesc.IsRoot)
        {
            WriteEnumAndArrayTypes();
        }
        ilg.Else();
        if (structMapping.TypeDesc.IsRoot)
        {
            MethodInfo method5 = typeof(XmlSerializationReader).GetMethod("ReadTypedPrimitive", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, new Type[1] { localBuilder.LocalType });
            ilg.Ldarg(0);
            ilg.Ldloc(localBuilder);
            ilg.Call(method5);
            ilg.Stloc(ilg.ReturnLocal);
            ilg.Br(ilg.ReturnLabel);
        }
        else
        {
            MethodInfo method6 = typeof(XmlSerializationReader).GetMethod("CreateUnknownTypeException", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, new Type[1] { typeof(XmlQualifiedName) });
            ilg.Ldarg(0);
            ilg.Ldloc(localBuilder);
            ilg.Call(method6);
            ilg.Throw();
        }
        ilg.EndIf();
        ilg.EndIf();
        if (structMapping.TypeDesc.IsNullable)
        {
            ilg.Ldloc(typeof(bool), "isNull");
            ilg.If();
            ilg.Load(null);
            ilg.Stloc(ilg.ReturnLocal);
            ilg.Br(ilg.ReturnLabel);
            ilg.EndIf();
        }
        if (structMapping.TypeDesc.IsAbstract)
        {
            MethodInfo method7 = typeof(XmlSerializationReader).GetMethod("CreateAbstractTypeException", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, new Type[2]
            {
                typeof(string),
                typeof(string)
            });
            ilg.Ldarg(0);
            ilg.Ldstr(GetCSharpString(structMapping.TypeName));
            ilg.Ldstr(GetCSharpString(structMapping.Namespace));
            ilg.Call(method7);
            ilg.Throw();
        }
        else
        {
            if (structMapping.TypeDesc.Type != null && typeof(XmlSchemaObject).IsAssignableFrom(structMapping.TypeDesc.Type))
            {
                MethodInfo method8 = typeof(XmlSerializationReader).GetMethod("set_DecodeName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, new Type[1] { typeof(bool) });
                ilg.Ldarg(0);
                ilg.Ldc(boolVar: false);
                ilg.Call(method8);
            }
            WriteCreateMapping(structMapping, "o");
            LocalBuilder local = ilg.GetLocal("o");
            MemberMapping[] settableMembers = TypeScope.GetSettableMembers(structMapping, memberInfos);
            Member member = null;
            Member member2 = null;
            Member member3 = null;
            bool flag = structMapping.HasExplicitSequence();
            List<Member> list3 = new List<Member>(settableMembers.Length);
            List<Member> list4 = new List<Member>(settableMembers.Length);
            List<Member> list5 = new List<Member>(settableMembers.Length);
            for (int i = 0; i < settableMembers.Length; i++)
            {
                MemberMapping memberMapping = settableMembers[i];
                CodeIdentifier.CheckValidIdentifier(memberMapping.Name);
                string stringForMember = base.RaCodeGen.GetStringForMember("o", memberMapping.Name, structMapping.TypeDesc);
                Member member4 = new Member(this, stringForMember, "a", i, memberMapping, GetChoiceIdentifierSource(memberMapping, "o", structMapping.TypeDesc));
                if (!memberMapping.IsSequence)
                {
                    member4.ParamsReadSource = $"paramsRead[{i}]";
                }
                member4.IsNullable = memberMapping.TypeDesc.IsNullable;
                if (memberMapping.CheckSpecified == SpecifiedAccessor.ReadWrite)
                {
                    member4.CheckSpecifiedSource = base.RaCodeGen.GetStringForMember("o", memberMapping.Name + "Specified", structMapping.TypeDesc);
                }
                if (memberMapping.Text != null)
                {
                    member = member4;
                }
                if (memberMapping.Attribute != null && memberMapping.Attribute.Any)
                {
                    member3 = member4;
                }
                if (!flag)
                {
                    for (int j = 0; j < memberMapping.Elements.Length; j++)
                    {
                        if (memberMapping.Elements[j].Any && (memberMapping.Elements[j].Name == null || memberMapping.Elements[j].Name.Length == 0))
                        {
                            member2 = member4;
                            break;
                        }
                    }
                }
                else if (memberMapping.IsParticle && !memberMapping.IsSequence)
                {
                    structMapping.FindDeclaringMapping(memberMapping, out var declaringMapping, structMapping.TypeName);
                    throw new InvalidOperationException(System.SR.Format(System.SR.XmlSequenceHierarchy, structMapping.TypeDesc.FullName, memberMapping.Name, declaringMapping.TypeDesc.FullName, "Order"));
                }
                if (memberMapping.Attribute == null && memberMapping.Elements.Length == 1 && memberMapping.Elements[0].Mapping is ArrayMapping)
                {
                    Member member5 = new Member(this, stringForMember, stringForMember, "a", i, memberMapping, GetChoiceIdentifierSource(memberMapping, "o", structMapping.TypeDesc));
                    member5.CheckSpecifiedSource = member4.CheckSpecifiedSource;
                    list5.Add(member5);
                }
                else
                {
                    list5.Add(member4);
                }
                if (!memberMapping.TypeDesc.IsArrayLike)
                {
                    continue;
                }
                list3.Add(member4);
                if (memberMapping.TypeDesc.IsArrayLike && (memberMapping.Elements.Length != 1 || !(memberMapping.Elements[0].Mapping is ArrayMapping)))
                {
                    member4.ParamsReadSource = null;
                    if (member4 != member && member4 != member2)
                    {
                        list4.Add(member4);
                    }
                }
                else if (!memberMapping.TypeDesc.IsArray)
                {
                    member4.ParamsReadSource = null;
                }
            }
            if (member2 != null)
            {
                list4.Add(member2);
            }
            if (member != null && member != member2)
            {
                list4.Add(member);
            }
            Member[] members = list3.ToArray();
            Member[] members2 = list4.ToArray();
            Member[] members3 = list5.ToArray();
            WriteMemberBegin(members);
            WriteParamsRead(settableMembers.Length);
            WriteAttributes(members3, member3, "UnknownNode", local);
            if (member3 != null)
            {
                WriteMemberEnd(members);
            }
            MethodInfo method9 = typeof(XmlSerializationReader).GetMethod("get_Reader", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            MethodInfo method10 = typeof(XmlReader).GetMethod("MoveToElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            ilg.Ldarg(0);
            ilg.Call(method9);
            ilg.Call(method10);
            ilg.Pop();
            MethodInfo method11 = typeof(XmlReader).GetMethod("get_IsEmptyElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            ilg.Ldarg(0);
            ilg.Call(method9);
            ilg.Call(method11);
            ilg.If();
            MethodInfo method12 = typeof(XmlReader).GetMethod("Skip", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            ilg.Ldarg(0);
            ilg.Call(method9);
            ilg.Call(method12);
            WriteMemberEnd(members2);
            ilg.Ldloc(local);
            ilg.Stloc(ilg.ReturnLocal);
            ilg.Br(ilg.ReturnLabel);
            ilg.EndIf();
            MethodInfo method13 = typeof(XmlReader).GetMethod("ReadStartElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            ilg.Ldarg(0);
            ilg.Call(method9);
            ilg.Call(method13);
            if (IsSequence(members3))
            {
                ilg.Ldc(0);
                ilg.Stloc(typeof(int), "state");
            }
            WriteWhileNotLoopStart();
            string text = "UnknownNode((object)o, " + ExpectedElements(members3) + ");";
            WriteMemberElements(members3, text, text, member2, member);
            MethodInfo method14 = typeof(XmlReader).GetMethod("MoveToContent", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            ilg.Ldarg(0);
            ilg.Call(method9);
            ilg.Call(method14);
            ilg.Pop();
            WriteWhileLoopEnd();
            WriteMemberEnd(members2);
            MethodInfo method15 = typeof(XmlSerializationReader).GetMethod("ReadEndElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            ilg.Ldarg(0);
            ilg.Call(method15);
            ilg.Ldloc(structMapping.TypeDesc.Type, "o");
            ilg.Stloc(ilg.ReturnLocal);
        }
        ilg.MarkLabel(ilg.ReturnLabel);
        ilg.Ldloc(ilg.ReturnLocal);
        ilg.EndMethod();
    }

References System.Collections.Generic.Dictionary< TKey, TValue >.Add(), System.SR.Arg_NeverValueType, System.Xml.Serialization.CodeGenerator.BeginMethod(), System.Xml.Serialization.CodeGenerator.Br(), System.Xml.Serialization.CodeGenerator.Br_S(), System.Xml.Serialization.CodeGenerator.Brtrue(), System.Xml.Serialization.CodeGenerator.Call(), System.Xml.Serialization.CodeGenerator.Ceq(), System.Xml.Serialization.CodeIdentifier.CheckValidIdentifier(), System.Xml.Serialization.CodeGenerator.DeclareLocal(), System.Xml.Serialization.CodeGenerator.DefineLabel(), System.Xml.Dictionary, System.Xml.Serialization.CodeGenerator.Else(), System.Type.EmptyTypes, System.Xml.Serialization.CodeGenerator.EndIf(), System.Xml.Serialization.CodeGenerator.EndMethod(), System.Xml.Serialization.XmlSerializationReaderILGen.ExpectedElements(), System.SR.Format(), System.Xml.Serialization.XmlSerializationReaderILGen.GetChoiceIdentifierSource(), System.Xml.Serialization.XmlSerializationILGen.GetCSharpString(), System.Xml.Serialization.CodeGenerator.GetLocal(), System.Xml.Serialization.XmlSerializationILGen.GetMethodBuilder(), System.Xml.Serialization.TypeScope.GetSettableMembers(), System.Text.RegularExpressions.i, System.Xml.Serialization.CodeGenerator.If(), System.Xml.Serialization.XmlSerializationILGen.ilg, System.Xml.Serialization.XmlSerializationReaderILGen.IsSequence(), System.Xml.Serialization.CodeGenerator.Ldarg(), System.Xml.Serialization.CodeGenerator.Ldc(), System.Xml.Serialization.CodeGenerator.Ldloc(), System.Xml.Serialization.CodeGenerator.Ldstr(), System.list, System.Xml.Serialization.CodeGenerator.Load(), System.Xml.Serialization.CodeGenerator.MarkLabel(), System.Xml.Serialization.XmlSerializationILGen.memberInfos, System.Xml.Serialization.CodeGenerator.New(), System.Xml.Serialization.Globals.NotSupported(), System.Xml.Serialization.CodeGenerator.Pop(), System.Xml.Serialization.CodeGenerator.ReturnLabel, System.Xml.Serialization.CodeGenerator.ReturnLocal, System.Xml.Serialization.CodeGenerator.Stloc(), System.text, System.Xml.Serialization.CodeGenerator.Throw(), System.Collections.Generic.Dictionary< TKey, TValue >.TryGetValue(), System.Xml.Serialization.XmlSerializationILGen.typeBuilder, System.value, System.Xml.Serialization.XmlSerializationReaderILGen.WriteAttributes(), System.Xml.Serialization.XmlSerializationReaderILGen.WriteCreateMapping(), System.Xml.Serialization.XmlSerializationReaderILGen.WriteDerivedTypes(), System.Xml.Serialization.XmlSerializationReaderILGen.WriteEnumAndArrayTypes(), System.Xml.Serialization.XmlSerializationReaderILGen.WriteMemberBegin(), System.Xml.Serialization.XmlSerializationReaderILGen.WriteMemberElements(), System.Xml.Serialization.XmlSerializationReaderILGen.WriteMemberEnd(), System.Xml.Serialization.XmlSerializationReaderILGen.WriteParamsRead(), System.Xml.Serialization.XmlSerializationReaderILGen.WriteQNameEqual(), System.Xml.Serialization.XmlSerializationReaderILGen.WriteWhileLoopEnd(), System.Xml.Serialization.XmlSerializationReaderILGen.WriteWhileNotLoopStart(), and System.SR.XmlSequenceHierarchy.

Referenced by System.Xml.Serialization.XmlSerializationReaderILGen.WriteStructMethod().