◆ WriteElement()

void System.Xml.Serialization.XmlSerializationWriterILGen.WriteElement	(	SourceInfo	source,
		ElementAccessor	element,
		string	arrayName,
		bool	writeAccessor )
inlineprivate
Definition at line 1636 of file XmlSerializationWriterILGen.cs.
    {
        string text = (writeAccessor ? element.Name : element.Mapping.TypeName);
        string text2 = ((element.Any && element.Name.Length == 0) ? null : ((element.Form != XmlSchemaForm.Qualified) ? "" : (writeAccessor ? element.Namespace : element.Mapping.Namespace)));
        if (element.Mapping is NullableMapping)
        {
            if (source.Type == element.Mapping.TypeDesc.Type)
            {
                MethodInfo method = element.Mapping.TypeDesc.Type.GetMethod("get_HasValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
                source.LoadAddress(element.Mapping.TypeDesc.Type);
                ilg.Call(method);
            }
            else
            {
                source.Load(null);
                ilg.Load(null);
                ilg.Cne();
            }
            ilg.If();
            SourceInfo sourceInfo = source.CastTo(element.Mapping.TypeDesc.BaseTypeDesc);
            ElementAccessor elementAccessor = element.Clone();
            elementAccessor.Mapping = ((NullableMapping)element.Mapping).BaseMapping;
            WriteElement(elementAccessor.Any ? source : sourceInfo, elementAccessor, arrayName, writeAccessor);
            if (element.IsNullable)
            {
                ilg.Else();
                WriteLiteralNullTag(element.Name, (element.Form == XmlSchemaForm.Qualified) ? element.Namespace : "");
            }
            ilg.EndIf();
            return;
        }
        if (element.Mapping is ArrayMapping)
        {
            ArrayMapping arrayMapping = (ArrayMapping)element.Mapping;
            if (element.IsUnbounded)
            {
                throw Globals.NotSupported("Unreachable: IsUnbounded is never set true!");
            }
            ilg.EnterScope();
            string cSharpName = arrayMapping.TypeDesc.CSharpName;
            WriteArrayLocalDecl(cSharpName, arrayName, source, arrayMapping.TypeDesc);
            if (element.IsNullable)
            {
                WriteNullCheckBegin(arrayName, element);
            }
            else if (arrayMapping.TypeDesc.IsNullable)
            {
                ilg.Ldloc(ilg.GetLocal(arrayName));
                ilg.Load(null);
                ilg.If(Cmp.NotEqualTo);
            }
            WriteStartElement(text, text2, writePrefixed: false);
            WriteArrayItems(arrayMapping.ElementsSortedByDerivation, null, null, arrayMapping.TypeDesc, arrayName, null);
            WriteEndElement();
            if (element.IsNullable)
            {
                ilg.EndIf();
            }
            else if (arrayMapping.TypeDesc.IsNullable)
            {
                ilg.EndIf();
            }
            ilg.ExitScope();
            return;
        }
        if (element.Mapping is EnumMapping)
        {
            WritePrimitive("WriteElementString", text, text2, element.Default, source, element.Mapping, writeXsiType: false, isElement: true, element.IsNullable);
            return;
        }
        if (element.Mapping is PrimitiveMapping)
        {
            PrimitiveMapping primitiveMapping = (PrimitiveMapping)element.Mapping;
            if (primitiveMapping.TypeDesc == base.QnameTypeDesc)
            {
                WriteQualifiedNameElement(text, text2, GetConvertedDefaultValue(source.Type, element.Default), source, element.IsNullable, primitiveMapping);
                return;
            }
            string text3 = (primitiveMapping.TypeDesc.XmlEncodingNotRequired ? "Raw" : "");
            WritePrimitive(element.IsNullable ? ("WriteNullableStringLiteral" + text3) : ("WriteElementString" + text3), text, text2, GetConvertedDefaultValue(source.Type, element.Default), source, primitiveMapping, writeXsiType: false, isElement: true, element.IsNullable);
            return;
        }
        if (element.Mapping is StructMapping)
        {
            StructMapping structMapping = (StructMapping)element.Mapping;
            string methodName = ReferenceMapping(structMapping);
            List<Type> list = new List<Type>();
            ilg.Ldarg(0);
            ilg.Ldstr(GetCSharpString(text));
            list.Add(typeof(string));
            ilg.Ldstr(GetCSharpString(text2));
            list.Add(typeof(string));
            source.Load(structMapping.TypeDesc.Type);
            list.Add(structMapping.TypeDesc.Type);
            if (structMapping.TypeDesc.IsNullable)
            {
                ilg.Ldc(element.IsNullable);
                list.Add(typeof(bool));
            }
            ilg.Ldc(boolVar: false);
            list.Add(typeof(bool));
            MethodBuilder methodInfo = EnsureMethodBuilder(typeBuilder, methodName, MethodAttributes.Private | MethodAttributes.HideBySig, typeof(void), list.ToArray());
            ilg.Call(methodInfo);
            return;
        }
        if (element.Mapping is SpecialMapping)
        {
            if (element.Mapping is SerializableMapping)
            {
                WriteElementCall("WriteSerializable", typeof(IXmlSerializable), source, text, text2, element.IsNullable, !element.Any);
                return;
            }
            Label label = ilg.DefineLabel();
            Label label2 = ilg.DefineLabel();
            source.Load(null);
            ilg.IsInst(typeof(XmlNode));
            ilg.Brtrue(label);
            source.Load(null);
            ilg.Load(null);
            ilg.Ceq();
            ilg.Br(label2);
            ilg.MarkLabel(label);
            ilg.Ldc(boolVar: true);
            ilg.MarkLabel(label2);
            ilg.If();
            WriteElementCall("WriteElementLiteral", typeof(XmlNode), source, text, text2, element.IsNullable, element.Any);
            ilg.Else();
            MethodInfo method2 = typeof(XmlSerializationWriter).GetMethod("CreateInvalidAnyTypeException", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, new Type[1] { typeof(object) });
            ilg.Ldarg(0);
            source.Load(null);
            ilg.Call(method2);
            ilg.Throw();
            ilg.EndIf();
            return;
        }
        throw new InvalidOperationException(System.SR.XmlInternalError);
    }
Referenced by System.Xml.Serialization.XmlSerializationWriterILGen.WriteElement(), and System.Xml.Serialization.XmlSerializationWriterILGen.WriteElements().