◆ WriteElement()

void System.Xml.Serialization.ReflectionXmlSerializationWriter.WriteElement	(	object	o,
		ElementAccessor	element,
		bool	writeAccessor )
inlineprivate
Definition at line 277 of file ReflectionXmlSerializationWriter.cs.
    {
        string text = (writeAccessor ? element.Name : element.Mapping.TypeName);
        string ns = ((element.Any && element.Name.Length == 0) ? null : ((element.Form != XmlSchemaForm.Qualified) ? string.Empty : (writeAccessor ? element.Namespace : element.Mapping.Namespace)));
        if (element.Mapping is NullableMapping nullableMapping)
        {
            if (o != null)
            {
                ElementAccessor elementAccessor = element.Clone();
                elementAccessor.Mapping = nullableMapping.BaseMapping;
                WriteElement(o, elementAccessor, writeAccessor);
            }
            else if (element.IsNullable)
            {
                WriteNullTagLiteral(element.Name, ns);
            }
            return;
        }
        if (element.Mapping is ArrayMapping)
        {
            ArrayMapping arrayMapping = element.Mapping as ArrayMapping;
            if (element.IsNullable && o == null)
            {
                WriteNullTagLiteral(element.Name, (element.Form == XmlSchemaForm.Qualified) ? element.Namespace : string.Empty);
                return;
            }
            if (arrayMapping.IsSoap)
            {
                if (arrayMapping.Elements == null || arrayMapping.Elements.Length != 1)
                {
                    throw new InvalidOperationException(System.SR.XmlInternalError);
                }
                if (!writeAccessor)
                {
                    WritePotentiallyReferencingElement(text, ns, o, arrayMapping.TypeDesc.Type, suppressReference: true, element.IsNullable);
                }
                else
                {
                    WritePotentiallyReferencingElement(text, ns, o, null, suppressReference: false, element.IsNullable);
                }
                return;
            }
            if (element.IsUnbounded)
            {
                IEnumerable enumerable = (IEnumerable)o;
                {
                    foreach (object item in enumerable)
                    {
                        element.IsUnbounded = false;
                        WriteElement(item, element, writeAccessor);
                        element.IsUnbounded = true;
                    }
                    return;
                }
            }
            if (o != null)
            {
                WriteStartElement(text, ns, writePrefixed: false);
                WriteArrayItems(arrayMapping.ElementsSortedByDerivation, null, null, arrayMapping.TypeDesc, o);
                WriteEndElement();
            }
            return;
        }
        if (element.Mapping is EnumMapping)
        {
            if (element.Mapping.IsSoap)
            {
                base.Writer.WriteStartElement(text, ns);
                WriteEnumMethod((EnumMapping)element.Mapping, o);
                WriteEndElement();
            }
            else
            {
                WritePrimitive(WritePrimitiveMethodRequirement.WriteElementString, text, ns, element.Default, o, element.Mapping, writeXsiType: false, isElement: true, element.IsNullable);
            }
            return;
        }
        if (element.Mapping is PrimitiveMapping)
        {
            PrimitiveMapping primitiveMapping = element.Mapping as PrimitiveMapping;
            if (primitiveMapping.TypeDesc == ReflectionXmlSerializationReader.QnameTypeDesc)
            {
                WriteQualifiedNameElement(text, ns, element.Default, (XmlQualifiedName)o, element.IsNullable, primitiveMapping.IsSoap, primitiveMapping);
            }
            else if (o == null && element.IsNullable)
            {
                if (primitiveMapping.IsSoap)
                {
                    WriteNullTagEncoded(element.Name, ns);
                }
                else
                {
                    WriteNullTagLiteral(element.Name, ns);
                }
            }
            else
            {
                WritePrimitiveMethodRequirement writePrimitiveMethodRequirement = (primitiveMapping.IsSoap ? WritePrimitiveMethodRequirement.Encoded : WritePrimitiveMethodRequirement.None);
                WritePrimitiveMethodRequirement writePrimitiveMethodRequirement2 = (primitiveMapping.TypeDesc.XmlEncodingNotRequired ? WritePrimitiveMethodRequirement.Raw : WritePrimitiveMethodRequirement.None);
                WritePrimitive(element.IsNullable ? (WritePrimitiveMethodRequirement.WriteNullableStringLiteral | writePrimitiveMethodRequirement | writePrimitiveMethodRequirement2) : (WritePrimitiveMethodRequirement.WriteElementString | writePrimitiveMethodRequirement2), text, ns, element.Default, o, primitiveMapping, primitiveMapping.IsSoap, isElement: true, element.IsNullable);
            }
            return;
        }
        if (element.Mapping is StructMapping)
        {
            StructMapping structMapping = element.Mapping as StructMapping;
            if (structMapping.IsSoap)
            {
                WritePotentiallyReferencingElement(text, ns, o, (!writeAccessor) ? structMapping.TypeDesc.Type : null, !writeAccessor, element.IsNullable);
            }
            else
            {
                WriteStructMethod(structMapping, text, ns, o, element.IsNullable, needType: false);
            }
            return;
        }
        if (element.Mapping is SpecialMapping)
        {
            if (element.Mapping is SerializableMapping)
            {
                WriteSerializable((IXmlSerializable)o, text, ns, element.IsNullable, !element.Any);
                return;
            }
            if (o is XmlNode node)
            {
                WriteElementLiteral(node, text, ns, element.IsNullable, element.Any);
                return;
            }
            throw CreateInvalidAnyTypeException(o);
        }
        throw new InvalidOperationException(System.SR.XmlInternalError);
    }
Referenced by System.Xml.Serialization.ReflectionXmlSerializationWriter.WriteElement(), and System.Xml.Serialization.ReflectionXmlSerializationWriter.WriteElements().