What is the best way to build XML in C# code?

Question

Please indicate your best practices for building XML using C#.

Edit:

With the help of Shog9, I just learned about the "community wiki" feature, and happily turned it on.

If you like a particular answer, vote it up. If you don't like a particular answer, feel free to shake your fist violently in the air and vote it down.

Answer 1

It depends on the scenario. XmlSerializer is certainly one way, and has the advantage of mapping directly to an object model. In .NET 3.5, XDocument etc are also very friendly. If the size is very large, then XmlWriter is your friend.

For an XDocument example:

    Console.WriteLine(
        new XElement("Foo",
            new XAttribute("Bar", "some & value"),
            new XElement("Nested", "data")));

Or the same with XmlDocument:

    XmlDocument doc = new XmlDocument();
    XmlElement el = (XmlElement)doc.AppendChild(doc.CreateElement("Foo"));
    el.SetAttribute("Bar", "some & value");
    el.AppendChild(doc.CreateElement("Nested")).InnerText = "data";
    Console.WriteLine(doc.OuterXml);

If you are writing a large stream of data, then any of the DOM approaches (such as XmlDocument/XDocument etc) will quickly take a lot of memory. So if you are writing a 100MB xml file from csv, you might consider XmlWriter; this is more primative (a write-once firehose), but very efficient (imagine a big loop here):

    XmlWriter writer = XmlWriter.Create(Console.Out);
    writer.WriteStartElement("Foo");
    writer.WriteAttributeString("Bar", "Some & value");
    writer.WriteElementString("Nested", "data");
    writer.WriteEndElement();

Finally, via XmlSerializer:

    [Serializable]
    public class Foo
    {
        [XmlAttribute]
        public string Bar { get; set; }
        public string Nested { get; set; }
    }
    ...
    Foo foo = new Foo
    {
        Bar = "some & value",
        Nested = "data"
    };
    new XmlSerializer(typeof(Foo)).Serialize(Console.Out, foo);

This is a nice model for mapping to classes etc; however, it might be overkill if you are doing something simple (or if the desired xml doesn't really have a direct correlation to the object model). Another issue with XmlSerializer is that it doesn't like to serialize immutable types : everything must have a public getter and setter (unless you do it all yourself by implementing IXmlSerializable, in which case you haven't gained much by using XmlSerializer).

Answer 2

I would give XLINQ (read: LINQ to XML) a try. It's easy, intuitive and is easily editable.

Answer 3

XmlWriter is the fastest way to write good XML. XDocument, XMLDocument and some others works good aswell, but are not optimized for writing XML. If you want to write the XML as fast as possible, you should definitely use XmlWriter.

Answer 4

For simple things, I just use the XmlDocument/XmlNode/XmlAttribute classes and XmlDocument DOM found in System.XML.

It generates the XML for me, I just need to link a few items together.

However, on larger things, I use XML serialization.

Answer 5

Also check out the Mark Resmussen's XmlDocument fluent interface, which really provides easy to type/read XML output.

Answer 6

For simple cases, I would also suggest looking at XmlOutput a fluent interface for building Xml.

XmlOutput is great for simple Xml creation with readable and maintainable code, while generating valid Xml. The orginal post has some great examples.

Answer 7

In the past I have created my XML Schema, then used a tool to generate C# classes which will serialize to that schema. The XML Schema Definition Tool is one example

http://msdn.microsoft.com/en-us/library/x6c1kb0s(VS.71).aspx

Answer 8

As above.

I use stringbuilder.append().

Very straightforward, and you can then do xmldocument.load(strinbuilder object as parameter).

You will probably find yourself using string.concat within the append parameter, but this is a very straightforward approach.

Answer 9

The best thing hands down that I have tried is LINQ to XSD (which is unknown to most developers). You give it an XSD Schema and it generates a perfectly mapped complete strongly-typed object model (based on LINQ to XML) for you in the background, which is really easy to work with - and it updates and validates your object model and XML in real-time. While it's still "Preview", I have not encountered any bugs with it.

If you have an XSD Schema that looks like this:

  <xs:element name="RootElement">
     <xs:complexType>
      <xs:sequence>
        <xs:element name="Element1" type="xs:string" />
        <xs:element name="Element2" type="xs:string" />
      </xs:sequence>
       <xs:attribute name="Attribute1" type="xs:integer use="optional" />
       <xs:attribute name="Attribute2" type="xs:boolean" use="required" />
     </xs:complexType>
  </xs:element>

Then you can simply build XML like this:

RootElement rootElement = new RootElement;
rootElement.Element1 = "Element1";
rootEleemnt.Element2 = "Element2";
rootEleemnt.Attribute1 = 5;
rootEleemnt.Attribute2 = true;

Or simply load an XML from file like this:

RootElement rootElement = RootElement.Load(filePath);

Or save it like this:

rootElement.Save(string);
rootElement.Save(textWriter);
rootElement.Save(xmlWriter);

rootElement.Untyped also yields the element in form of a XElement (from LINQ to XML).

Answer 10

new XElement("Foo",
       from s in nameValuePairList
       select
             new XElement("Bar",
                  new XAttribute("SomeAttr", "SomeAttrValue"),
                          new XElement("Name", s.Name),
                          new XElement("Value", s.Value)
                         )
            );