Skip to main content

C# XML Handling

XML (eXtensible Markup Language) is a widely used format for storing and transporting structured data. In C#, the .NET Framework provides robust tools for working with XML documents. This guide will walk you through the fundamentals of XML handling in C#, from basic operations to more advanced scenarios.

What is XML?​

XML is a markup language that defines rules for encoding documents in a format that is both human-readable and machine-readable. It's often used for:

  • Configuration files
  • Data storage
  • Web services communication (SOAP)
  • Data exchange between different systems

Here's a simple XML example:

xml
<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
  <book category="fiction">
    <title>Harry Potter</title>
    <author>J.K. Rowling</author>
    <price>19.99</price>
  </book>
  <book category="programming">
    <title>C# in Depth</title>
    <author>Jon Skeet</author>
    <price>39.99</price>
  </book>
</bookstore>

XML Classes in .NET​

C# provides several classes to work with XML:

  1. System.Xml Namespace:

    • XmlDocument: DOM (Document Object Model) based XML manipulation
    • XmlReader/XmlWriter: Fast, forward-only access to XML

  2. System.Xml.Linq Namespace:

    • XDocument: LINQ-enabled XML document
    • XElement: LINQ-enabled XML element

Let's explore these options for handling XML in C#.

Reading XML with XmlDocument​

XmlDocument provides a DOM-based approach to reading and manipulating XML.

csharp
using System;
using System.Xml;

class Program
{
    static void Main()
    {
        // Create and load the XML document
        XmlDocument doc = new XmlDocument();
        doc.Load("bookstore.xml");
        
        // Get all book nodes
        XmlNodeList bookNodes = doc.SelectNodes("//book");
        
        // Process each book
        foreach (XmlNode bookNode in bookNodes)
        {
            string title = bookNode.SelectSingleNode("title").InnerText;
            string author = bookNode.SelectSingleNode("author").InnerText;
            string price = bookNode.SelectSingleNode("price").InnerText;
            string category = bookNode.Attributes["category"].Value;
            
            Console.WriteLine($"Title: {title}");
            Console.WriteLine($"Author: {author}");
            Console.WriteLine($"Price: ${price}");
            Console.WriteLine($"Category: {category}");
            Console.WriteLine();
        }
    }
}

Output:

Title: Harry Potter
Author: J.K. Rowling
Price: $19.99
Category: fiction

Title: C# in Depth
Author: Jon Skeet
Price: $39.99
Category: programming

Reading XML with XmlReader​

For large XML files, XmlReader provides a fast, forward-only, read-only access to XML data.

csharp
using System;
using System.Xml;

class Program
{
    static void Main()
    {
        using (XmlReader reader = XmlReader.Create("bookstore.xml"))
        {
            string currentElement = "";
            bool insideBook = false;
            string title = "", author = "", price = "", category = "";

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    currentElement = reader.Name;
                    
                    if (currentElement == "book")
                    {
                        insideBook = true;
                        if (reader.HasAttributes)
                            category = reader.GetAttribute("category");
                    }
                }
                else if (reader.NodeType == XmlNodeType.Text && insideBook)
                {
                    switch (currentElement)
                    {
                        case "title":
                            title = reader.Value;
                            break;
                        case "author":
                            author = reader.Value;
                            break;
                        case "price":
                            price = reader.Value;
                            break;
                    }
                }
                else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "book")
                {
                    Console.WriteLine($"Title: {title}");
                    Console.WriteLine($"Author: {author}");
                    Console.WriteLine($"Price: ${price}");
                    Console.WriteLine($"Category: {category}");
                    Console.WriteLine();
                    
                    // Reset for next book
                    insideBook = false;
                    title = author = price = category = "";
                }
            }
        }
    }
}

Modern XML Handling with LINQ to XML​

LINQ to XML provides a more modern and intuitive way to work with XML.

Reading XML with XDocument​

csharp
using System;
using System.Linq;
using System.Xml.Linq;

class Program
{
    static void Main()
    {
        // Load XML document
        XDocument doc = XDocument.Load("bookstore.xml");
        
        // Query with LINQ
        var books = from book in doc.Descendants("book")
                    select new
                    {
                        Title = book.Element("title").Value,
                        Author = book.Element("author").Value,
                        Price = decimal.Parse(book.Element("price").Value),
                        Category = book.Attribute("category").Value
                    };
        
        // Display results
        foreach (var book in books)
        {
            Console.WriteLine($"Title: {book.Title}");
            Console.WriteLine($"Author: {book.Author}");
            Console.WriteLine($"Price: ${book.Price}");
            Console.WriteLine($"Category: {book.Category}");
            Console.WriteLine();
        }
    }
}

Creating XML with LINQ to XML​

Creating XML documents is straightforward with LINQ to XML:

csharp
using System;
using System.Xml.Linq;

class Program
{
    static void Main()
    {
        // Create a new XML document
        XDocument doc = new XDocument(
            new XDeclaration("1.0", "UTF-8", "yes"),
            new XElement("bookstore",
                new XElement("book",
                    new XAttribute("category", "fiction"),
                    new XElement("title", "The Great Gatsby"),
                    new XElement("author", "F. Scott Fitzgerald"),
                    new XElement("price", "12.99")
                ),
                new XElement("book",
                    new XAttribute("category", "programming"),
                    new XElement("title", "Clean Code"),
                    new XElement("author", "Robert C. Martin"),
                    new XElement("price", "34.99")
                )
            )
        );
        
        // Save the document
        doc.Save("new_bookstore.xml");
        
        // Display the XML to console
        Console.WriteLine(doc.ToString());
    }
}

Output (new_bookstore.xml):

xml
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<bookstore>
  <book category="fiction">
    <title>The Great Gatsby</title>
    <author>F. Scott Fitzgerald</author>
    <price>12.99</price>
  </book>
  <book category="programming">
    <title>Clean Code</title>
    <author>Robert C. Martin</author>
    <price>34.99</price>
  </book>
</bookstore>

Modifying XML with LINQ to XML​

LINQ to XML makes it easy to modify existing XML documents:

csharp
using System;
using System.Xml.Linq;

class Program
{
    static void Main()
    {
        // Load document
        XDocument doc = XDocument.Load("bookstore.xml");
        
        // Find all programming books and update prices
        foreach (var book in doc.Descendants("book")
                              .Where(b => b.Attribute("category").Value == "programming"))
        {
            // Get current price
            var priceElement = book.Element("price");
            decimal currentPrice = decimal.Parse(priceElement.Value);
            
            // Apply 10% discount
            decimal newPrice = Math.Round(currentPrice * 0.9m, 2);
            priceElement.Value = newPrice.ToString();
        }
        
        // Add a new book
        doc.Root.Add(
            new XElement("book",
                new XAttribute("category", "science"),
                new XElement("title", "A Brief History of Time"),
                new XElement("author", "Stephen Hawking"),
                new XElement("price", "15.99")
            )
        );
        
        // Save changes
        doc.Save("updated_bookstore.xml");
        
        Console.WriteLine("XML file updated successfully!");
    }
}

XML Serialization​

XML serialization is the process of converting objects into XML format and vice versa. This is useful for saving object state or transferring objects between systems.

Serializing an Object to XML​

csharp
using System;
using System.IO;
using System.Xml.Serialization;

public class Book
{
    public string Title { get; set; }
    public string Author { get; set; }
    public decimal Price { get; set; }
    public string Category { get; set; }
}

class Program
{
    static void Main()
    {
        // Create a book object
        Book book = new Book
        {
            Title = "The Pragmatic Programmer",
            Author = "Andrew Hunt & David Thomas",
            Price = 29.99m,
            Category = "Programming"
        };
        
        // Create XML serializer
        XmlSerializer serializer = new XmlSerializer(typeof(Book));
        
        // Serialize to file
        using (TextWriter writer = new StreamWriter("book.xml"))
        {
            serializer.Serialize(writer, book);
        }
        
        Console.WriteLine("Book serialized to XML successfully!");
        
        // Display the XML
        Console.WriteLine(File.ReadAllText("book.xml"));
    }
}

Output (book.xml):

xml
<?xml version="1.0" encoding="utf-8"?>
<Book xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Title>The Pragmatic Programmer</Title>
  <Author>Andrew Hunt &amp; David Thomas</Author>
  <Price>29.99</Price>
  <Category>Programming</Category>
</Book>

Deserializing XML to an Object​

csharp
using System;
using System.IO;
using System.Xml.Serialization;

// Using the same Book class from previous example

class Program
{
    static void Main()
    {
        // Create XML serializer
        XmlSerializer serializer = new XmlSerializer(typeof(Book));
        
        // Deserialize from file
        Book book;
        using (TextReader reader = new StreamReader("book.xml"))
        {
            book = (Book)serializer.Deserialize(reader);
        }
        
        // Display book details
        Console.WriteLine("Deserialized Book:");
        Console.WriteLine($"Title: {book.Title}");
        Console.WriteLine($"Author: {book.Author}");
        Console.WriteLine($"Price: ${book.Price}");
        Console.WriteLine($"Category: {book.Category}");
    }
}

Output:

Deserialized Book:
Title: The Pragmatic Programmer
Author: Andrew Hunt & David Thomas
Price: $29.99
Category: Programming

XML Validation with Schema​

You can validate XML against an XSD (XML Schema Definition) to ensure it follows a specific structure:

csharp
using System;
using System.Xml;
using System.Xml.Schema;

class Program
{
    static void Main()
    {
        // Create the XML reader
        XmlReaderSettings settings = new XmlReaderSettings();
        settings.Schemas.Add(null, "bookstore.xsd");
        settings.ValidationType = ValidationType.Schema;
        
        // Set up validation event handler
        settings.ValidationEventHandler += ValidationEventHandler;
        
        using (XmlReader reader = XmlReader.Create("bookstore.xml", settings))
        {
            // Read the XML file and validate
            while (reader.Read()) { }
            Console.WriteLine("XML validation completed.");
        }
    }
    
    static void ValidationEventHandler(object sender, ValidationEventArgs e)
    {
        if (e.Severity == XmlSeverityType.Error)
        {
            Console.WriteLine($"Validation Error: {e.Message}");
        }
        else
        {
            Console.WriteLine($"Validation Warning: {e.Message}");
        }
    }
}

Real-World Example: Configuration File​

XML is commonly used for configuration files. Let's look at a practical example where we read application settings from an XML file:

csharp
using System;
using System.Xml.Linq;

class Program
{
    static void Main()
    {
        // Application configuration
        AppConfig config = LoadConfiguration("appconfig.xml");
        
        // Use configuration settings
        Console.WriteLine($"Application: {config.AppName} v{config.Version}");
        Console.WriteLine($"Database Connection: {config.DbConnection}");
        Console.WriteLine("Feature Toggles:");
        foreach (var feature in config.FeatureToggles)
        {
            Console.WriteLine($"  - {feature.Key}: {(feature.Value ? "Enabled" : "Disabled")}");
        }
    }
    
    static AppConfig LoadConfiguration(string path)
    {
        try
        {
            XDocument doc = XDocument.Load(path);
            var configElement = doc.Element("configuration");
            
            AppConfig config = new AppConfig
            {
                AppName = configElement.Element("appName").Value,
                Version = configElement.Element("version").Value,
                DbConnection = configElement.Element("database").Element("connectionString").Value
            };
            
            // Load feature toggles
            foreach (var toggle in configElement.Element("featureToggles").Elements("feature"))
            {
                string name = toggle.Attribute("name").Value;
                bool enabled = bool.Parse(toggle.Attribute("enabled").Value);
                config.FeatureToggles[name] = enabled;
            }
            
            return config;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error loading configuration: {ex.Message}");
            return new AppConfig();  // Return default config
        }
    }
}

class AppConfig
{
    public string AppName { get; set; } = "Default App";
    public string Version { get; set; } = "1.0.0";
    public string DbConnection { get; set; } = "";
    public Dictionary<string, bool> FeatureToggles { get; set; } = new Dictionary<string, bool>();
}

Example appconfig.xml:

xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
  <appName>My Awesome App</appName>
  <version>2.1.3</version>
  <database>
    <connectionString>Server=localhost;Database=MyDB;User=admin;Password=secret;</connectionString>
  </database>
  <featureToggles>
    <feature name="DarkMode" enabled="true" />
    <feature name="BetaTesting" enabled="false" />
    <feature name="Analytics" enabled="true" />
  </featureToggles>
</configuration>

Working with Large XML Files​

For very large XML files, memory usage becomes a concern. Here's how to handle large files efficiently:

csharp
using System;
using System.Xml;

class Program
{
    static void Main()
    {
        long count = 0;
        
        using (XmlReader reader = XmlReader.Create("verylarge.xml"))
        {
            string currentElement = "";
            
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    currentElement = reader.Name;
                    
                    // Count only specific elements
                    if (currentElement == "product")
                    {
                        count++;
                        
                        if (count % 10000 == 0)
                        {
                            Console.WriteLine($"Processed {count} products...");
                        }
                        
                        // Optionally extract just what you need
                        if (reader.HasAttributes)
                        {
                            string id = reader.GetAttribute("id");
                            // Process specific products if needed
                            if (id == "12345")
                            {
                                Console.WriteLine("Found target product!");
                            }
                        }
                    }
                }
            }
        }
        
        Console.WriteLine($"Total products: {count}");
    }
}

Summary​

In this guide, we've explored the various ways to handle XML in C#:

  1. XML Reading and Parsing:

    • Using XmlDocument for DOM-based manipulation
    • Using XmlReader for efficient, forward-only reading
    • Using XDocument and LINQ for modern, query-based operations

  2. XML Creation and Modification:

    • Creating XML documents with XDocument and LINQ to XML
    • Modifying existing XML structures

  3. XML Serialization:

    • Converting objects to XML
    • Converting XML back to objects

  4. XML Validation:

    • Validating XML against schemas

  5. Practical Applications:

    • Working with configuration files
    • Handling large XML files efficiently

XML remains an important format in many applications, particularly for configuration files, data exchange, and interoperability between different systems. Understanding how to efficiently work with XML in C# is an essential skill for any .NET developer.

Additional Resources​

Exercises​

  1. Create an XML file representing a list of movies with title, director, year, and genre. Write a C# program to read this file and display movies from a specific genre.

  2. Create a C# application that reads an XML configuration file similar to the one in our real-world example. Add error handling to manage missing elements or attributes.

  3. Write a program that serializes a list of custom objects to XML and then deserializes them back.

  4. Create an XML transformer that reads an XML file of products and generates a new XML file with a different structure (e.g., grouping products by category).

  5. Build an XML editor that allows adding, modifying, and removing elements and attributes from an existing XML file.


If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)