Differences in XML Serialization when [XmlElement] and [XmlText] are Combined

• Download source code - 8.2 KB
• https://github.com/IfatChitin/XmlElementCombinedWithXmlText

Introduction

This tip shows the differences in XML serialization when a serializable class has a combination of [XmlElement] and [XmlText].

Background

XML serialization can be done in various ways and techniques. In this tip, I would like to show a difference I experienced with a serializable class declaring a collection as [XmlElement] and a string as [XmlText].

Using the Code

Serializable Class

This class has the following properties:

• A string as an attribute - [XmlAttribute]
• A string as a text attribute - [XmlText]
• A collection as an element - [XmlElement]

[XmlType(AnonymousType = true)]
public class Person
{
    [XmlAttribute("name")]
    public string Name { get; set; }

    [XmlText]
    public string Text { get; set; }

    [XmlElement("person")]
    public Collection<Person> Children { get; set; }

    public bool ShouldSerializeChildren()
    {
        return Children != null && Children.Count > 0;
    }

    public string Serialize()
    {
        var sw = new StringWriter();

        var serializer = new XmlSerializer(typeof(Person));
        var ns = new XmlSerializerNamespaces();
        ns.Add("", "");
        serializer.Serialize(sw, this, ns);

        return sw.ToString();
    }
}

Serializing the Class Without Assigning a Text Property

Assigning only the name attribute and the collection element.

var person = new Person
{
    Name = "name",
    Children =
        new Collection<Person>
        {
            new Person {Name = "child1", Text = "child1Text"},
            new Person {Name = "child2", Text = "child2Text"}
        }
};

var personWithoutText = person.Serialize();

Console.WriteLine("Person without text attribute has new lines:");
Console.WriteLine("-------------------------------------------");
Console.WriteLine(personWithoutText);
Console.WriteLine();

The Result

The result would be a nice indented XML with newlines between the collection items.

<?xml version="1.0" encoding="utf-16"?>
<Person name="name">
  <person name="child1">child1Text</person>
  <person name="child2">child2Text</person>
</Person>

Serializing the Class After Assigning a Text Property

person.Text = "text";

            var personWithTextAttribue = person.Serialize();
            Console.WriteLine("Person with text attribute has no new lines:");
            Console.WriteLine("-------------------------------------------");
            Console.WriteLine(personWithTextAttribue);

            Console.ReadLine();

The Result

The result would be an XML without newlines between the collection items.

<?xml version="1.0" encoding="utf-16"?>
<Person name="name">text<person name="child1">child1Text</person>
<person name="child2">child2Text</person></Person>

Conclusion

The workaround I found for having newlines between collection items, was to make sure there is no text attribute in the serializable class.

Points of Interest

Why did I declare the collection property as XmlElement?

A collection that is not declared as XmlElement, its items are encoded as a sequence of elements, nested under an element named after the property. (See XmlElementAttribute in MSDN)

Something like this:

<myserializableclass>
    <wrappingelement>
        <item>item1</item>
        <item>item2</item>
        <item>item3</item>
    <myserializableclass>
</myserializableclass>

In order to avoid the element wrapping the collection's items, I am declaring the collection as [XmlElement].
The serialization result would then be:

<MySerializableClass>
    <item>item1</item>
    <item>item2</item>
    <item>item3</item>
 </MySerializableClass>

History

• 14^th February, 2015: Initial version
• 17^th February, 2015: Edited conclusion and updated code (fixed namespace and XML attributes)