How to deal with XML in C#

The primary means of reading and writing in C# 2.0 is done through the XmlDocument class. You can load most of your settings directly into the XmlDocument through the XmlReader it accepts.

Loading XML Directly

XmlDocument document = new XmlDocument();document.LoadXml("<People><Person Name='Nick' /><Person Name='Joe' /></People>");

Loading XML From a File

XmlDocument document = new XmlDocument();document.Load(@"C:\Path\To\xmldoc.xml");// Or using an XmlReader/XmlTextReaderXmlReader reader = XmlReader.Create(@"C:\Path\To\xmldoc.xml");document.Load(reader);

I find the easiest/fastest way to read an XML document is by using XPath.

Reading an XML Document using XPath (Using XmlDocument which allows us to edit)

XmlDocument document = new XmlDocument();document.LoadXml("<People><Person Name='Nick' /><Person Name='Joe' /></People>");// Select a single nodeXmlNode node = document.SelectSingleNode("/People/Person[@Name = 'Nick']");// Select a list of nodesXmlNodeList nodes = document.SelectNodes("/People/Person");

If you need to work with XSD documents to validate an XML document you can use this.

Validating XML Documents against XSD Schemas

XmlReaderSettings settings = new XmlReaderSettings();settings.ValidateType = ValidationType.Schema;settings.Schemas.Add("", pathToXsd); // targetNamespace, pathToXsdXmlReader reader = XmlReader.Create(pathToXml, settings);XmlDocument document = new XmlDocument();try {    document.Load(reader);} catch (XmlSchemaValidationException ex) { Trace.WriteLine(ex.Message); }

Validating XML against XSD at each Node (UPDATE 1)

XmlReaderSettings settings = new XmlReaderSettings();settings.ValidateType = ValidationType.Schema;settings.Schemas.Add("", pathToXsd); // targetNamespace, pathToXsdsettings.ValidationEventHandler += new ValidationEventHandler(settings_ValidationEventHandler);XmlReader reader = XmlReader.Create(pathToXml, settings);while (reader.Read()) { }private void settings_ValidationEventHandler(object sender, ValidationEventArgs args){    // e.Message, e.Severity (warning, error), e.Error    // or you can access the reader if you have access to it    // reader.LineNumber, reader.LinePosition.. etc}

Writing an XML Document (manually)

XmlWriter writer = XmlWriter.Create(pathToOutput);writer.WriteStartDocument();writer.WriteStartElement("People");writer.WriteStartElement("Person");writer.WriteAttributeString("Name", "Nick");writer.WriteEndElement();writer.WriteStartElement("Person");writer.WriteStartAttribute("Name");writer.WriteValue("Nick");writer.WriteEndAttribute();writer.WriteEndElement();writer.WriteEndElement();writer.WriteEndDocument();writer.Flush();

(UPDATE 1)

In .NET 3.5, you use XDocument to perform similar tasks. The difference however is you have the advantage of performing Linq Queries to select the exact data you need. With the addition of object initializers you can create a query that even returns objects of your own definition right in the query itself.

    XDocument doc = XDocument.Load(pathToXml);    List<Person> people = (from xnode in doc.Element("People").Elements("Person")                       select new Person                       {                           Name = xnode.Attribute("Name").Value                       }).ToList();

(UPDATE 2)

A nice way in .NET 3.5 is to use XDocument to create XML is below. This makes the code appear in a similar pattern to the desired output.

XDocument doc =        new XDocument(              new XDeclaration("1.0", Encoding.UTF8.HeaderName, String.Empty),              new XComment("Xml Document"),              new XElement("catalog",                    new XElement("book", new XAttribute("id", "bk001"),                          new XElement("title", "Book Title")                    )              )        );

creates

<!--Xml Document--><catalog>  <book id="bk001">    <title>Book Title</title>  </book></catalog>

All else fails, you can check out this MSDN article that has many examples that I've discussed here and more.http://msdn.microsoft.com/en-us/library/aa468556.aspx

It depends on the size; for small to mid size xml, a DOM such as XmlDocument (any C#/.NET versions) or XDocument (.NET 3.5/C# 3.0) is the obvious winner. For using xsd, You can load xml using an XmlReader, and an XmlReader accepts (to Create) an XmlReaderSettings. The XmlReaderSettings objects has a Schemas property that can be used to perform xsd (or dtd) validation.

For writing xml, the same things apply, noting that it is a little easier to lay out content with LINQ-to-XML (XDocument) than the older XmlDocument.

However, for huge xml, a DOM may chomp too much memory, in which case you might need to use XmlReader/XmlWriter directly.

Finally, for manipulating xml you may wish to use XslCompiledTransform (an xslt layer).

The alternative to working with xml is to work with an object model; you can use xsd.exe to create classes that represent an xsd-compliant model, and simply load the xml as objects, manipulate it with OO, and then serialize those objects again; you do this with XmlSerializer.

nyxtom's answer is very good. I'd add a couple of things to it:

If you need read-only access to an XML document, XPathDocument is a much lighter-weight object than XmlDocument.

The downside of using XPathDocument is that you can't use the familiar SelectNodes and SelectSingleNode methods of XmlNode. Instead, you have to use the tools that the IXPathNavigable provides: use CreateNavigator to create an XPathNavigator, and use the XPathNavigator to create XPathNodeIterators to iterate over the lists of nodes you find via XPath. This generally requires a few more lines of code than the XmlDocument methods.

But: the XmlDocument and XmlNode classes implement IXPathNavigable, so any code you write to use those methods on an XPathDocument will also work on an XmlDocument. If you get used to writing against IXPathNavigable, your methods can work against either object. (This is why using XmlNode and XmlDocument in method signatures is flagged by FxCop.)

Lamentably, XDocument and XElement (and XNode and XObject) don't implement IXPathNavigable.

Another thing not present in nyxtom's answer is XmlReader. You generally use XmlReader to avoid the overhead of parsing the XML stream into an object model before you begin processing it. Instead, you use an XmlReader to process the input stream one XML node at a time. This is essentially .NET's answer to SAX. It lets you write very fast code for processing very large XML documents.

XmlReader also provides the simplest way of processing XML document fragments, e.g. the stream of XML elements with no encluding element that SQL Server's FOR XML RAW option returns.

The code you write using XmlReader is generally very tightly coupled to the format of the XML it's reading. Using XPath allows your code to be much, much more loosely coupled to the XML, which is why it's generally the right answer. But when you need to use XmlReader, you really need it.