VB.NET – Create XML from DataTable Rows

Web Development
1

VB.NET – Create XML from DataTable Rows
VB.NET – Create XML from DataTable Rows1024×1024 71.8 KB

Working with XML in VB.NET is a common task when dealing with data storage, configuration files, or communication between systems. One particularly useful use case is converting a DataTable—often used in Windows Forms or ADO.NET-based applications—into a structured XML format.

In this guide, we’ll explore how to generate clean, well-structured XML from rows in a DataTable using VB.NET. Whether you’re working with translations, configurations, or exporting tabular data, this step-by-step blog will guide you through everything you need.

1. Introduction to XML Creation in VB.NET

XML (Extensible Markup Language) is a markup language used to store and transport data. In VB.NET, XML creation and manipulation can be done using the XmlDocument, XmlWriter, or LINQ to XML.

In our case, we’ll use the XmlDocument class to create a structured XML document based on rows in a DataTable.

The goal is to produce an XML file in the format below:

<?xml version="1.0" encoding="utf-8"?>
<body>
  <trans-unit>
    <source>Some Text-1</source>
    <target />
  </trans-unit>
  <trans-unit>
    <source>Some Text-2</source>
    <target />
  </trans-unit>
</body>

This format is often used in translation systems, configuration tools, and lightweight data exchanges.

2. Preparing the DataTable

Before creating XML, we need a sample DataTable with data. Here’s how you can define and populate it in your VB.NET application:

Dim dtTranslation As New DataTable()
dtTranslation.Columns.Add("Source")
dtTranslation.Columns.Add("Target")

dtTranslation.Rows.Add("Welcome", "")
dtTranslation.Rows.Add("Thank You", "")
dtTranslation.Rows.Add("Goodbye", "")

This example simulates a translation table where the “Source” field has the original text and the “Target” field is to be translated later.

Tip from wwebhub: Always make sure your columns are named properly and data types are compatible with your XML structure. Incorrect column names can lead to unexpected behavior when writing XML.

3. Creating the XML File with XmlDocument

Now let’s build the XML structure from the DataTable.

Here’s the complete code:

Private Sub CreateXmlFromDataTable(dt As DataTable, filePath As String)
Dim xdoc As New XmlDocument()

' XML declaration
Dim declaration As XmlDeclaration = xdoc.CreateXmlDeclaration("1.0", "utf-8", Nothing)
xdoc.AppendChild(declaration)

' Root element <body>
Dim xRoot As XmlElement = xdoc.CreateElement("body")
xdoc.AppendChild(xRoot)

' Loop through each row to create <trans-unit> structure
For Each row As DataRow In dt.Rows
    Dim xTU As XmlElement = xdoc.CreateElement("trans-unit")

    Dim xSource As XmlElement = xdoc.CreateElement("source")
    xSource.InnerText = row("Source").ToString()

    Dim xTarget As XmlElement = xdoc.CreateElement("target")
    If Not IsDBNull(row("Target")) AndAlso Not String.IsNullOrWhiteSpace(row("Target").ToString()) Then
        xTarget.InnerText = row("Target").ToString()
    End If

    xTU.AppendChild(xSource)
    xTU.AppendChild(xTarget)
    xRoot.AppendChild(xTU)
Next

xdoc.Save(filePath)

End Sub

Call this method like so:

CreateXmlFromDataTable(dtTranslation, “E:\Temp\TranslationOutput.xml”)



## **4. Understanding the XML Output Structure**

Let’s break down the XML that this code generates:

* **`<body>`** is the root element holding all units.
* **`<trans-unit>`** represents one row from the DataTable.
* **`<source>`** holds the source text.
* **`<target>`** is left empty for future translations.

The structure is clean, minimal, and ready for integration with translation platforms or configuration tools.

>  **From aaskfullstack**: Use meaningful tags (`trans-unit`, `source`, `target`) for clarity and compatibility with industry standards like XLIFF or custom schemas.


## **5. Error Handling and Best Practices**

Here are a few tips to make your XML generation more robust:

* **Validate column existence**: Always check if the DataTable has the required columns.
* **Handle nulls**: Use `IsDBNull()` to avoid runtime errors.
* **Use `XmlTextWriter`** for large data**: If you are working with large tables, `XmlTextWriter` might offer better performance.
* **Pretty formatting**: For human readability, use `XmlWriterSettings` with `Indent = True`.

Example:


Dim settings As New XmlWriterSettings()
settings.Indent = True

6. Real-world Use Cases and Enhancements

Here are some enhancements and use cases:

  • Multi-language translation files: Use this method to export content for translators.
  • Configuration files: Store settings in XML using structured rows.
  • Data export/import: Allow users to save and load data in XML format.

Possible Enhancements:

  • Add attributes like id to <trans-unit>.
  • Include a <note> element for translator notes.
  • Convert the XML to/from other formats (JSON, CSV).

Final Thoughts

Creating XML from a DataTable in VB.NET is straightforward when you use the right tools and follow a clean structure. Whether for translations, configurations, or structured data exchange, this method will help you automate and scale your applications.

Keep refining your approach as your XML needs grow. For more practical examples and beginner-to-advanced guides, you can always refer to wwebhub for XML use cases or check aaskfullstack for .NET-based data handling tutorials.