◆ GenerateLiteralMembersElement()

string System.Xml.Serialization.XmlSerializationReaderILGen.GenerateLiteralMembersElement ( XmlMembersMapping xmlMembersMapping )
inlineprivate
Definition at line 387 of file XmlSerializationReaderILGen.cs.
    {
        ElementAccessor accessor = xmlMembersMapping.Accessor;
        MemberMapping[] members = ((MembersMapping)accessor.Mapping).Members;
        bool hasWrapperElement = ((MembersMapping)accessor.Mapping).HasWrapperElement;
        string text = NextMethodName(accessor.Name);
        ilg = new CodeGenerator(typeBuilder);
        ilg.BeginMethod(typeof(object[]), text, Type.EmptyTypes, Array.Empty<string>(), MethodAttributes.Public | MethodAttributes.HideBySig);
        ilg.Load(null);
        ilg.Stloc(ilg.ReturnLocal);
        MethodInfo method = typeof(XmlSerializationReader).GetMethod("get_Reader", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
        MethodInfo method2 = typeof(XmlReader).GetMethod("MoveToContent", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
        ilg.Ldarg(0);
        ilg.Call(method);
        ilg.Call(method2);
        ilg.Pop();
        LocalBuilder localBuilder = ilg.DeclareLocal(typeof(object[]), "p");
        ilg.NewArray(typeof(object), members.Length);
        ilg.Stloc(localBuilder);
        InitializeValueTypes("p", members);
        if (hasWrapperElement)
        {
            WriteWhileNotLoopStart();
            WriteIsStartTag(accessor.Name, (accessor.Form == XmlSchemaForm.Qualified) ? accessor.Namespace : "");
        }
        Member anyText = null;
        Member anyElement = null;
        Member anyAttribute = null;
        List<Member> list = new List<Member>();
        List<Member> list2 = new List<Member>();
        List<Member> list3 = new List<Member>();
        for (int i = 0; i < members.Length; i++)
        {
            MemberMapping memberMapping = members[i];
            string text2 = $"p[{i}]";
            string arraySource = text2;
            if (memberMapping.Xmlns != null)
            {
                arraySource = $"(({memberMapping.TypeDesc.CSharpName}){text2})";
            }
            string choiceIdentifierSource = GetChoiceIdentifierSource(members, memberMapping);
            Member member = new Member(this, text2, arraySource, "a", i, memberMapping, choiceIdentifierSource);
            Member member2 = new Member(this, text2, null, "a", i, memberMapping, choiceIdentifierSource);
            if (!memberMapping.IsSequence)
            {
                member.ParamsReadSource = $"paramsRead[{i}]";
            }
            if (memberMapping.CheckSpecified == SpecifiedAccessor.ReadWrite)
            {
                string text3 = memberMapping.Name + "Specified";
                for (int j = 0; j < members.Length; j++)
                {
                    if (members[j].Name == text3)
                    {
                        member.CheckSpecifiedSource = $"p[{j}]";
                        break;
                    }
                }
            }
            bool flag = false;
            if (memberMapping.Text != null)
            {
                anyText = member2;
            }
            if (memberMapping.Attribute != null && memberMapping.Attribute.Any)
            {
                anyAttribute = member2;
            }
            if (memberMapping.Attribute != null || memberMapping.Xmlns != null)
            {
                list3.Add(member);
            }
            else if (memberMapping.Text != null)
            {
                list2.Add(member);
            }
            if (!memberMapping.IsSequence)
            {
                for (int k = 0; k < memberMapping.Elements.Length; k++)
                {
                    if (memberMapping.Elements[k].Any && memberMapping.Elements[k].Name.Length == 0)
                    {
                        anyElement = member2;
                        if (memberMapping.Attribute == null && memberMapping.Text == null)
                        {
                            list2.Add(member2);
                        }
                        flag = true;
                        break;
                    }
                }
            }
            if (memberMapping.Attribute != null || memberMapping.Text != null || flag)
            {
                list.Add(member2);
                continue;
            }
            if (memberMapping.TypeDesc.IsArrayLike && (memberMapping.Elements.Length != 1 || !(memberMapping.Elements[0].Mapping is ArrayMapping)))
            {
                list.Add(member2);
                list2.Add(member2);
                continue;
            }
            if (memberMapping.TypeDesc.IsArrayLike && !memberMapping.TypeDesc.IsArray)
            {
                member.ParamsReadSource = null;
            }
            list.Add(member);
        }
        Member[] array = list.ToArray();
        Member[] members2 = list2.ToArray();
        if (array.Length != 0 && array[0].Mapping.IsReturnValue)
        {
            MethodInfo method3 = typeof(XmlSerializationReader).GetMethod("set_IsReturnValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, new Type[1] { typeof(bool) });
            ilg.Ldarg(0);
            ilg.Ldc(boolVar: true);
            ilg.Call(method3);
        }
        WriteParamsRead(members.Length);
        if (list3.Count > 0)
        {
            Member[] members3 = list3.ToArray();
            WriteMemberBegin(members3);
            WriteAttributes(members3, anyAttribute, "UnknownNode", localBuilder);
            WriteMemberEnd(members3);
            MethodInfo method4 = typeof(XmlReader).GetMethod("MoveToElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            ilg.Ldarg(0);
            ilg.Call(method);
            ilg.Call(method4);
            ilg.Pop();
        }
        WriteMemberBegin(members2);
        if (hasWrapperElement)
        {
            MethodInfo method5 = typeof(XmlReader).GetMethod("get_IsEmptyElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            ilg.Ldarg(0);
            ilg.Call(method);
            ilg.Call(method5);
            ilg.If();
            MethodInfo method6 = typeof(XmlReader).GetMethod("Skip", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            ilg.Ldarg(0);
            ilg.Call(method);
            ilg.Call(method6);
            ilg.Ldarg(0);
            ilg.Call(method);
            ilg.Call(method2);
            ilg.Pop();
            ilg.WhileContinue();
            ilg.EndIf();
            MethodInfo method7 = typeof(XmlReader).GetMethod("ReadStartElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            ilg.Ldarg(0);
            ilg.Call(method);
            ilg.Call(method7);
        }
        if (IsSequence(array))
        {
            ilg.Ldc(0);
            ilg.Stloc(typeof(int), "state");
        }
        WriteWhileNotLoopStart();
        string text4 = "UnknownNode((object)p, " + ExpectedElements(array) + ");";
        WriteMemberElements(array, text4, text4, anyElement, anyText);
        ilg.Ldarg(0);
        ilg.Call(method);
        ilg.Call(method2);
        ilg.Pop();
        WriteWhileLoopEnd();
        WriteMemberEnd(members2);
        if (hasWrapperElement)
        {
            MethodInfo method8 = typeof(XmlSerializationReader).GetMethod("ReadEndElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            ilg.Ldarg(0);
            ilg.Call(method8);
            WriteUnknownNode("UnknownNode", "null", accessor, anyIfs: true);
            ilg.Ldarg(0);
            ilg.Call(method);
            ilg.Call(method2);
            ilg.Pop();
            WriteWhileLoopEnd();
        }
        ilg.Ldloc(ilg.GetLocal("p"));
        ilg.EndMethod();
        return text;
    }
Referenced by System.Xml.Serialization.XmlSerializationReaderILGen.GenerateMembersElement().