WriteElement()

void System.Xml.Serialization.XmlSerializationReaderILGen.WriteElement ( string source, string arrayName, string choiceSource, ElementAccessor element, ChoiceIdentifierAccessor choice, string checkSpecified, bool checkForNull, bool readOnly, int fixupIndex, int elementIndex )

inlineprivate

Definition at line 2451 of file XmlSerializationReaderILGen.cs.

    {
        if (checkSpecified != null && checkSpecified.Length > 0)
        {
            ILGenSet(checkSpecified, true);
        }
        if (element.Mapping is ArrayMapping)
        {
            WriteArray(source, arrayName, (ArrayMapping)element.Mapping, readOnly, element.IsNullable, fixupIndex, elementIndex);
        }
        else if (element.Mapping is NullableMapping)
        {
            string methodName = ReferenceMapping(element.Mapping);
            WriteSourceBegin(source);
            ilg.Ldarg(0);
            ilg.Ldc(boolVar: true);
            MethodBuilder methodInfo = EnsureMethodBuilder(typeBuilder, methodName, MethodAttributes.Private | MethodAttributes.HideBySig, element.Mapping.TypeDesc.Type, new Type[1] { typeof(bool) });
            ilg.Call(methodInfo);
            WriteSourceEnd(source, element.Mapping.TypeDesc.Type);
        }
        else if (element.Mapping is PrimitiveMapping)
        {
            bool flag = false;
            if (element.IsNullable)
            {
                MethodInfo method = typeof(XmlSerializationReader).GetMethod("ReadNull", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
                ilg.Ldarg(0);
                ilg.Call(method);
                ilg.If();
                WriteSourceBegin(source);
                if (element.Mapping.TypeDesc.IsValueType)
                {
                    throw Globals.NotSupported("No such condition.  PrimitiveMapping && IsNullable = String, XmlQualifiedName and never IsValueType");
                }
                ilg.Load(null);
                WriteSourceEnd(source, element.Mapping.TypeDesc.Type);
                ilg.Else();
                flag = true;
            }
            if (element.Default != null && element.Default != DBNull.Value && element.Mapping.TypeDesc.IsValueType)
            {
                MethodInfo method2 = typeof(XmlSerializationReader).GetMethod("get_Reader", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
                MethodInfo method3 = typeof(XmlReader).GetMethod("get_IsEmptyElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
                ilg.Ldarg(0);
                ilg.Call(method2);
                ilg.Call(method3);
                ilg.If();
                MethodInfo method4 = typeof(XmlReader).GetMethod("Skip", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
                ilg.Ldarg(0);
                ilg.Call(method2);
                ilg.Call(method4);
                ilg.Else();
                flag = true;
            }
            if (element.Mapping.TypeDesc.Type == typeof(TimeSpan) || element.Mapping.TypeDesc.Type == typeof(DateTimeOffset))
            {
                MethodInfo method5 = typeof(XmlSerializationReader).GetMethod("get_Reader", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
                MethodInfo method6 = typeof(XmlReader).GetMethod("get_IsEmptyElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
                ilg.Ldarg(0);
                ilg.Call(method5);
                ilg.Call(method6);
                ilg.If();
                WriteSourceBegin(source);
                MethodInfo method7 = typeof(XmlReader).GetMethod("Skip", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
                ilg.Ldarg(0);
                ilg.Call(method5);
                ilg.Call(method7);
                LocalBuilder tempLocal = ilg.GetTempLocal(element.Mapping.TypeDesc.Type);
                ilg.Ldloca(tempLocal);
                ilg.InitObj(element.Mapping.TypeDesc.Type);
                ilg.Ldloc(tempLocal);
                WriteSourceEnd(source, element.Mapping.TypeDesc.Type);
                ilg.Else();
                WriteSourceBegin(source);
                WritePrimitive(element.Mapping, "Reader.ReadElementString()");
                WriteSourceEnd(source, element.Mapping.TypeDesc.Type);
                ilg.EndIf();
            }
            else
            {
                WriteSourceBegin(source);
                if (element.Mapping.TypeDesc == base.QnameTypeDesc)
                {
                    MethodInfo method8 = typeof(XmlSerializationReader).GetMethod("ReadElementQualifiedName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
                    ilg.Ldarg(0);
                    ilg.Call(method8);
                }
                else
                {
                    string formatterName = element.Mapping.TypeDesc.FormatterName;
                    WritePrimitive(source: (!(formatterName == "ByteArrayBase64") && !(formatterName == "ByteArrayHex")) ? "Reader.ReadElementString()" : "false", mapping: element.Mapping);
                }
                WriteSourceEnd(source, element.Mapping.TypeDesc.Type);
            }
            if (flag)
            {
                ilg.EndIf();
            }
        }
        else if (element.Mapping is StructMapping)
        {
            TypeMapping mapping = element.Mapping;
            string methodName2 = ReferenceMapping(mapping);
            if (checkForNull)
            {
                MethodInfo method9 = typeof(XmlSerializationReader).GetMethod("get_Reader", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
                MethodInfo method10 = typeof(XmlReader).GetMethod("Skip", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
                ilg.Ldloc(arrayName);
                ilg.Load(null);
                ilg.If(Cmp.EqualTo);
                ilg.Ldarg(0);
                ilg.Call(method9);
                ilg.Call(method10);
                ilg.Else();
            }
            WriteSourceBegin(source);
            List<Type> list = new List<Type>();
            ilg.Ldarg(0);
            if (mapping.TypeDesc.IsNullable)
            {
                ilg.Load(element.IsNullable);
                list.Add(typeof(bool));
            }
            ilg.Ldc(boolVar: true);
            list.Add(typeof(bool));
            MethodBuilder methodInfo2 = EnsureMethodBuilder(typeBuilder, methodName2, MethodAttributes.Private | MethodAttributes.HideBySig, mapping.TypeDesc.Type, list.ToArray());
            ilg.Call(methodInfo2);
            WriteSourceEnd(source, mapping.TypeDesc.Type);
            if (checkForNull)
            {
                ilg.EndIf();
            }
        }
        else
        {
            if (!(element.Mapping is SpecialMapping))
            {
                throw new InvalidOperationException(System.SR.XmlInternalError);
            }
            SpecialMapping specialMapping = (SpecialMapping)element.Mapping;
            switch (specialMapping.TypeDesc.Kind)
            {
            case TypeKind.Node:
            {
                bool flag3 = specialMapping.TypeDesc.FullName == typeof(XmlDocument).FullName;
                WriteSourceBeginTyped(source, specialMapping.TypeDesc);
                MethodInfo method13 = typeof(XmlSerializationReader).GetMethod(flag3 ? "ReadXmlDocument" : "ReadXmlNode", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, new Type[1] { typeof(bool) });
                ilg.Ldarg(0);
                ilg.Ldc(!element.Any);
                ilg.Call(method13);
                if (specialMapping.TypeDesc != null)
                {
                    ilg.Castclass(specialMapping.TypeDesc.Type);
                }
                WriteSourceEnd(source, specialMapping.TypeDesc.Type);
                break;
            }
            case TypeKind.Serializable:
            {
                SerializableMapping serializableMapping = (SerializableMapping)element.Mapping;
                if (serializableMapping.DerivedMappings != null)
                {
                    MethodInfo method11 = typeof(XmlSerializationReader).GetMethod("GetXsiType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
                    Label label = ilg.DefineLabel();
                    Label label2 = ilg.DefineLabel();
                    LocalBuilder localBuilder = ilg.DeclareOrGetLocal(typeof(XmlQualifiedName), "tser");
                    ilg.Ldarg(0);
                    ilg.Call(method11);
                    ilg.Stloc(localBuilder);
                    ilg.Ldloc(localBuilder);
                    ilg.Load(null);
                    ilg.Ceq();
                    ilg.Brtrue(label);
                    WriteQNameEqual("tser", serializableMapping.XsiType.Name, serializableMapping.XsiType.Namespace);
                    ilg.Br_S(label2);
                    ilg.MarkLabel(label);
                    ilg.Ldc(boolVar: true);
                    ilg.MarkLabel(label2);
                    ilg.If();
                }
                WriteSourceBeginTyped(source, serializableMapping.TypeDesc);
                bool flag2 = !element.Any && XmlSerializationILGen.IsWildcard(serializableMapping);
                MethodInfo method12 = typeof(XmlSerializationReader).GetMethod("ReadSerializable", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, (!flag2) ? new Type[1] { typeof(IXmlSerializable) } : new Type[2]
                {
                    typeof(IXmlSerializable),
                    typeof(bool)
                });
                ilg.Ldarg(0);
                base.RaCodeGen.ILGenForCreateInstance(ilg, serializableMapping.TypeDesc.Type, serializableMapping.TypeDesc.CannotNew, cast: false);
                if (serializableMapping.TypeDesc.CannotNew)
                {
                    ilg.ConvertValue(typeof(object), typeof(IXmlSerializable));
                }
                if (flag2)
                {
                    ilg.Ldc(boolVar: true);
                }
                ilg.Call(method12);
                if (serializableMapping.TypeDesc != null)
                {
                    ilg.ConvertValue(typeof(IXmlSerializable), serializableMapping.TypeDesc.Type);
                }
                WriteSourceEnd(source, serializableMapping.TypeDesc.Type);
                if (serializableMapping.DerivedMappings != null)
                {
                    WriteDerivedSerializable(serializableMapping, serializableMapping, source, flag2);
                    WriteUnknownNode("UnknownNode", "null", null, anyIfs: true);
                }
                break;
            }
            default:
                throw new InvalidOperationException(System.SR.XmlInternalError);
            }
        }
        if (choice != null)
        {
            WriteSourceBegin(choiceSource);
            CodeIdentifier.CheckValidIdentifier(choice.MemberIds[elementIndex]);
            base.RaCodeGen.ILGenForEnumMember(ilg, choice.Mapping.TypeDesc.Type, choice.MemberIds[elementIndex]);
            WriteSourceEnd(choiceSource, choice.Mapping.TypeDesc.Type);
        }
    }

References System.Xml.Serialization.Accessor.Any, System.Xml.Serialization.CodeIdentifier.CheckValidIdentifier(), System.Xml.Serialization.Accessor.Default, System.Xml.Dictionary, System.elementIndex, System.Type.EmptyTypes, System.Xml.Serialization.TypeDesc.FormatterName, System.Xml.Serialization.ElementAccessor.IsNullable, System.Xml.Serialization.TypeDesc.IsValueType, System.Xml.Serialization.XmlSerializationILGen.IsWildcard(), System.list, System.Xml.Serialization.Accessor.Mapping, System.Xml.Serialization.Globals.NotSupported(), System.source, System.Xml.Serialization.TypeDesc.Type, System.Xml.Serialization.TypeMapping.TypeDesc, System.DBNull.Value, and System.SR.XmlInternalError.

Referenced by System.Xml.Serialization.XmlSerializationReaderILGen.WriteMemberElementsElse(), System.Xml.Serialization.XmlSerializationReaderILGen.WriteMemberElementsIf(), and System.Xml.Serialization.XmlSerializationReaderILGen.WriteNullableMethod().