Jump to content

Working with XML

From Knowledge Base
  1. XML in CSharp

In C# you can use the built-in System.Xml namespace to extract data from XML files and write XML files. There are two common approaches for working with XML in .NET:

Streaming approach (Using XmlReader and XmlWriter)

The streaming approach is more memory-efficient for large XML files, as it processes the XML sequentially without loading the entire document into memory. Here's an example: 

using System;
using System.Xml;

// Reading from an XML file using XmlReader
using (XmlReader reader = XmlReader.Create("data.xml"))
{
    while (reader.Read())
    {
        if (reader.NodeType == XmlNodeType.Element && reader.Name == "element")
        {
            string value = reader.ReadElementContentAsString();
            Console.WriteLine(value);
        }
    }
}

// Writing to an XML file using XmlWriter
using (XmlWriter writer = XmlWriter.Create("newdata.xml"))
{
    writer.WriteStartDocument();
    writer.WriteStartElement("root");
    writer.WriteElementString("element", "NewValue");
    writer.WriteEndElement();
    writer.WriteEndDocument();
}

DOM approach (Using XmlDocument)

This approach loads the entire XML document into memory as a tree structure, allowing you to traverse and manipulate the XML data easily. Here's an example of how to extract data from an XML file and write to an XML file using XmlDocument: 

using System;
using System.Xml;

// Load an XML document
XmlDocument doc = new XmlDocument();
doc.Load("data.xml");

// Extract data from the XML
XmlNodeList nodes = doc.SelectNodes("/root/element"); // XPath query
foreach (XmlNode node in nodes)
{
    string value = node.InnerText;
    Console.WriteLine(value);
}
// Create a new XML document and write data to it
XmlDocument newDoc = new XmlDocument();
XmlElement root = newDoc.CreateElement("root");
XmlElement element = newDoc.CreateElement("element");
element.InnerText = "NewValue";
root.AppendChild(element);
newDoc.AppendChild(root);
newDoc.Save("newdata.xml");

XML structure in "data.xml" 

xml
<root>
    <element>
        <id>1</id>
        <name>John</name>
    </element>
    <element>
        <id>2</id>
        <name>Jane</name>
    </element>
</root>

C# class to represent the data 

public class Data
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Use XmlDocument to read and map the XML data to a list of MyData objects: 

using System;
using System.Xml;

List<Data> dataList = new List<Data>();

XmlDocument doc = new XmlDocument();
doc.Load("data.xml");

XmlNodeList nodes = doc.SelectNodes("/root/element"); // SelectNodes method
foreach (XmlNode node in nodes)
{
    Data data = new Data
    {
        Id = int.Parse(node.SelectSingleNode("id").InnerText),
        Name = node.SelectSingleNode("name").InnerText
    };

    dataList.Add(data);
}

foreach (var data in dataList)
{
    Console.WriteLine($"Id: {data.Id}, Name: {data.Name}");
}

If you're working with more complex XML data or need more advanced mapping capabilities, you may want to consider using a third-party library like AutoMapper or writing your own custom mapping logic to make the process more efficient and maintainable. In the example above, the `SelectNodes` method is a crucial part of the implementation when working with XmlDocument to select and extract specific nodes from the XML document. This method allows you to query the XML document using an XPath expression and retrieve a collection of matching nodes. 

XmlNodeList nodes = doc.SelectNodes("/root/element");

In this line, the XPath expression "/root/element" is used to select all "element" nodes that are direct children of the "root" node. You can modify the XPath expression to match your specific XML structure and the nodes you want to extract.

XPath

XPath is a powerful and expressive language for navigating and querying XML documents. It allows you to specify paths to elements and attributes in an XML document, making it easy to retrieve specific data. Here's a brief overview of how XPath works:

Example XML Data: 

<library>
   <book>
      <title>XML Basics</title>
      <author>John Doe</author>
      <price>29.99</price>
   </book>
   <book>
      <title>XPath and XQuery</title>
      <author>Jane Smith</author>
      <price>39.99</price>
   </book>
   <book>
      <title>Web Development</title>
      <author>John Doe</author>
      <price>49.99</price>
   </book>
</library>

Expressions

Select All Titles 

XmlNodeList titles = doc.SelectNodes("/library/book/title");

Returns: 

   XML Basics
   XPath and XQuery
   Web Development

Select Books by Author 'John Doe' 

XmlNodeList johnDoeBooks = doc.SelectNodes("/library/book[author='John Doe']");

Returns: 

<book>
  <title>XML Basics</title>
  <author>John Doe</author>
  <price>29.99</price>
</book>
<book>
  <title>Web Development</title>
  <author>John Doe</author>
  <price>49.99</price>
</book>

Select Books with a Price Greater Than $30 

XmlNodeList expensiveBooks = doc.SelectNodes("/library/book[price > 30]");

Returns: 

<book>
  <title>XPath and XQuery</title>
  <author>Jane Smith</author>
  <price>39.99</price>
</book>
<book>
  <title>Web Development</title>
  <author>John Doe</author>
  <price>49.99</price>
</book>

Static

XPath expressions are often hardcoded when you're working with XML data, especially in scenarios where you know the structure of the XML documents you're dealing with. Hardcoding XPath expressions is a common practice when you have a specific XML schema or a consistent structure in your XML documents.

Dynamic

However, there are situations where you might want to make your XPath expressions more dynamic or configurable:

  • Configuration Files: You can store XPath expressions in configuration files, making it easier to modify them without changing your code. This is useful when you need to adapt to changes in the XML structure.
  • User Input: If you're building a user interface that allows users to define their own XPath queries, you can make the queries dynamic by taking user input and using it to construct XPath expressions.
  • Parameterized Queries: In some programming languages and libraries, you can create parameterized XPath queries that allow you to insert variables or parameters into the expressions, making them more flexible.

Here's an example of a parameterized XPath query using C# and the System.Xml namespace: 

string targetElement = "book";
string isbnValue = "123";

string xpathExpression = $"/bookstore/{targetElement}[@ISBN='{isbnValue}']";

The `targetElement` and `isbnValue` variables are used to create a dynamic XPath expression. This can be useful when you need to change the target element or attribute value based on runtime conditions.

Side-note: Converting XML to JSON using Recursion in JavaScript: https://medium.com/@nitinpatel_20236/converting-xml-to-json-using-recursion-7b1df91b42d8

Retrieved from "https://christian-thorn.de/mediawiki/index.php?title=Working_with_XML&oldid=164"