# Working with XML Data Sources
{{< alert style="info" >}}This feature is only compatible with GroupDocs.Assembly for .NET 19.10 or later releases.{{< /alert >}}
To access XML data while building a report, you can use facilities of *DataSet* to read XML into it and then pass it to the assembler as a data source. However, if your scenario does not permit to specify XML schema while loading XML into *DataSet*, all attributes and text values of XML elements are loaded as strings then. Thus, it becomes impossible, for example, to use arithmetic operations on numbers or to specify custom date-time and numeric formats to output orresponding values, because all of them are treated as strings. To overcome this limitation, you can pass an *XmlDataSource* instance to the assembler as a data source instead. Even when XML schema is not provided, *XmlDataSource* is capable to recognize values of the following types by their string representations:
* Int32?
* Int64?
* Double?
* Boolean?
* DateTime?
{{< alert style="warning" >}}For recognition of data types to work, string representations of corresponding attributes and text values of XML elements must be formed using invariant culture settings.{{< /alert >}}
## Treating the top-level XML element contains only a sequence of elements of the same type
In template documents, if a top-level XML element contains only a sequence of elements of the same type, an *XmlDataSource* instance should be treated in the same way as if it was a *DataTable* instance (see "[Working with *DataTable* and *DataView* Objects](https://docs.groupdocs.com/assembly/net/template-syntax-part-1-of-2/#using-data-sources)" for more information).
Suppose we have XML data like:
```
John Doe
30
1989-04-01 4:00:00 pm
Jane Doe
27
1992-01-31 07:00:00 am
John Smith
51
1968-03-08 1:00:00 pm
```
By using the template like following:
```
<>Name: <<\[Name\]>>, Age: <<\[Age\]>>, Date of Birth:
<<\[Birth\]:"dd.MM.yyyy">>
<>
Average age: <<\[persons.Average(p => p.Age)\]>>
```
The results will be produced like:
```
Name: John Doe, Age: 30, Date of Birth: 01.04.1989
Name: Jane Doe, Age: 27, Date of Birth: 31.01.1992
Name: John Smith, Age: 51, Date of Birth: 08.03.1968
Average age: 36
```
{{< alert style="warning" >}}Using of the custom date-time format and the extension method involving arithmetic in the template document becomes possible, because text values of Birth and Age XML elements are automatically converted to DateTime? and Int32? respectively even in the absence of XML schema.{{< /alert >}}
{{< alert style="info" >}}Since version 26.11, nullable values of XML data are used in a template the same way as values of typed objects, without `.Value` or `== true`: `<<[o.Date.Month]>>`, `<<[o.Total.ToString("F2")]>>`, `<>`, `<<[o.Paid ? "paid" : "due"]>>` and predicates such as `orders.Where(x => x.Paid)` work directly. For a missing value, a member gives an empty value and a condition is false. See [Using nullable values like values of typed objects]({{< ref "assembly/net/developer-guide/advanced-usage/working-with-simple-data-sources/working-with-json-data-sources.md#using-nullable-values-like-values-of-typed-objects" >}}) for an example.{{< /alert >}}
## Treating the top-level XML element contains attributes or nested elements of different types
If a top-level XML element contains attributes or nested elements of different types, an *XmlDataSource* instance should be treated in template documents in the same way as if it was a *DataRow* instance (see "[Working with *DataRow* and *DataRowView* Objects](https://docs.groupdocs.com/assembly/net/template-syntax-part-1-of-2/#using-data-sources)" for more information) as shown in the following example.
Suppose we have XML data like:
```
John Doe
30
1989-04-01 4:00:00 pm
Ann Doe
Charles Doe
```
By using the template like following:
```
Name: <<\[Name\]>>, Age: <<\[Age\]>>, Date of Birth:
<<\[Birth\]:"dd.MM.yyyy">>
Children:
<><<\[Child\_Text\]>>
<>
```
The results will be produced like:
```
Name: John Doe, Age: 30, Date of Birth: 01.04.1989
Children:
Ann Doe
Charles Doe
```
{{< alert style="warning" >}}To reference a sequence of repeated simple-type XML elements with the same name, the elements’ name itself (for example, "Child") should be used in a template document, whereas the same name with the "_Text" suffix (for example, "Child_Text") should be used to reference the text value of one of these elements.{{< /alert >}}
## The complete example
The following example sums up typical scenarios involving nested complex-type XML elements.
### XML
```
John Smith
A Company
1200000
B Ltd.
750000
C & D
350000
Tony Anderson
E Corp.
650000
F & Partners
550000
July James
G & Co.
350000
H Group
250000
I & Sons
43
100000
J Ent.
100000
```
### Template document
```
<>Manager: <<\[Name\]>>
Contracts:
<>- <<\[Client.Name\]>> ($<<\[Price\]>>)
<>
<>
```
### Source code
{{< gist GroupDocsGists ddac17d9a69c71495b2931ca6c7e8ce7 >}}
### Result document
```
Manager: John Smith
Contracts:
- A Company ($1200000)
- B Ltd. ($750000)
- C & D ($350000)
Manager: Tony Anderson
Contracts:
- E Corp. ($650000)
- F & Partners ($550000)
Manager: July James
Contracts:
- G & Co. ($350000)
- H Group ($250000)
- I & Sons ($100000)
- J Ent. ($100000)
```
## Download
### Data Source Document
* [Managers.xml](https://github.com/groupdocs-assembly/GroupDocs.Assembly-for-.NET/blob/master/Examples/Data/Data%20Sources/XML%20DataSource/Managers.xml?raw=true)
### Template
* [Demo Template.docx](https://github.com/groupdocs-assembly/GroupDocs.Assembly-for-.NET/blob/master/Examples/Data/Source/Word%20Templates/Using%20Spreadsheet%20as%20Table%20of%20Data.docx?raw=true)