Generating XML Root Node Having Colon-Via Serialization

Recently, I got a requirement to generate an XML on the fly with some defined schema. I know this requirement looks very simple at first sight, but actually, it was not.

The XML which was to be generated was having a very specific format as it was supposed to be the input for some third-party tools. So, it means, it should be fully compliant with the prescribed XML node structure. Just have a look at the below schema.

<sl:RandomWindow xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:sl="" xsi:schemaLocation="">
<Title>First Window</Title>
<Border>Single</Border>
</sl:RandomWindow>

Below are the classes I created for serialization purposes.

public class RandomWindow
{
[XmlAttribute(Form=System.Xml.Schema.XmlSchemaForm.Qualified, Namespace="http://www.w3.org/2001/XMLSchema-instance")]
public string schemaLocation {get;set;}
[XmlElement]
public string Title {get;set;}
[XmlElement]
public string Border {get;set;}
}

By using the XmlElement and XmlAttribute classes, I was able to generate most of the required parts of the XML, as shown below.

<?xml version="1.0" encoding="UTF-8"?>
<RandomWindow xsi:schemaLocation="" xmlns:sl="" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<Title>First Window</Title>
<Border>Single</Border>
</RandomWindow>

But the only thing which didn’t come up correctly was the root node that is expected to be in the form <sl:RandomWindow>.

So, in order to achieve the root node with prefix and colon, I updated the code to -

[XmlRoot("sl:RandomWindow")]
public class RandomWindow {…}

But alas! It gave me some strange results. It converted the prefix to hexadecimal, as shown below. Then I thought, instead of providing a concrete prefix, let’s add namespace itself.

[XmlRoot("RandomWindow", Namespace = "")]
public class RandomWindow { ...}

And my result was a bit closer to what I need, but not the exact one. Now, the issue remaining was the extra prefix in front of each element :(.

In order to resolve this issue, I tried various options provided by various blogs, but no luck. However, after spending hours, I was able to crack it by a "hit and try" formula. To hide namespaces at element node level, I provided the namespace value as empty just like in the code shown below.

[XmlRoot("RandomWindow", Namespace="")]
public class RandomWindow
{
[XmlAttribute(Form=System.Xml.Schema.XmlSchemaForm.Qualified, Namespace="http://www.w3.org/2001/XMLSchema-instance")]
public string schemaLocation {get;set;}
[XmlElement(Namespace=" ")]
public string Title {get;set;}
[XmlElement(Namespace=" ")]
public string Border {get;set;}
}

And that did the trick for me. Finally, I was able to achieve the required format.

<?xml version="1.0" encoding="UTF-8"?>
<sl:RandomWindow xsi:schemaLocation="" xmlns:sl="" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<Title xmlns=" ">First Window</Title>
<Border xmlns=" ">Single</Border>
</sl:RandomWindow>

Although this issue was pretending to be very small, it ate up so much of my time. This is why I thought to share it here in hopes that it would be helpful for you and will save your time.

Happy troubleshooting !!!

JSON vs. XML

JSON vs. XML

Both JSON and XML are capable of representing in-memory data in a readable textual format. Similarly, both of them are isomorphic, which means an equivalent one of the given piece of text is possible in the other format. For instance, while invoking a public Web service, a developer can state in the query string parameter whether the output should be in XML or JSON format.

Due to such similarities, it might not be simple to choose a suitable data exchange format from the two. This is where it is essential to consider the differentiating characteristics or both the formats and find out which one is more suitable for a particular application.

Compares the major characteristics of both formats.

Characteristic	JSON	XML
Data Types	Offers scalar data types and articulates structured data in the form of objects and arrays	Does not offer any idea of data types due to which relying on XML Schema is essential for specifying information about the data types.
Array Support	Provides native support	Expresses array by conventions. For instance, XML employs an outer placeholder element that forms the content in an array as inner elements.
Object Support	Provides native support	Expresses objects by conventions, usually by combining attributes and elements.
Null Support	Recognizes the value natively.	Mandates the use of xsi:nil on elements in an instance document along with the import of the related namespace.
Comments	Does not support	Provides native support (via APIs).
Namespaces	Does not support namespaces and that naming collisions do not occur, as objects are nested or the object member name has a prefix.	Accepts namespaces to prevent name collisions and safely extent the prevalent XML standards.
Formatting	Is simple and offers more direct data mapping	It complex and needs more effort for mapping application types to elements.
Size	Has very short syntax, which gives formatted text wherein most space is taken up by the represented data.	Has lengthy documents, particularly in case of element-centric formatting.
Parsing in JavaScript	Has very short syntax, which gives formatted text wherein most space is taken up by the represented data.	Has lengthy documents, particularly in case of element-centric formatting.
Parsing in JavaScript	Needs no additional application for parsing (JavaScript’s eval() function work well ).	Implements XML DOM and requires extra code for mapping text to JavaScript objects.
Parsing	Has JSONPath for selecting specific sections of the data structure but is not widely used.	Has XPath specification for doing the same in an XML document and is widely used.
Learning Curve	Is not sleep at all, due to familiarity with the structure and the underlying dynamic programming language.	Is steep with the need to know several technologies and concepts such as XPath, XSL Transformations (XSLT), DOM, Schema, and Namespaces.
Complexity	Is complex	Is more complex.
Schema (Metadata)	Has a schema but is not widely used.	Used many specifications for defining a schema, including XML Schema Definition (XSD) and Document Type Definition (DTD)
Styling	Has no special specification.	Has XSLT specification for styling an XML document.
Security	Is less secure, as the browser has no JSON parser.	Is more secure.

XML Creation using LINQ to XML

There are many different techniques to use by which you can create an XML document in C#. One of them is LINQ to XML which we are going to discuss in this article.

Let’s say we need to create an XML as below:

<?xml version="1.0" encoding="UTF-8"?>
<Parent>
<Header>
<FileDetails>
<FileName>RandomFile</FileName>
<FileVersion>1.0</FileVersion>
</FileDetails>
</Header>
<Body>
<Infos>
<Info Type="Information1">This is Information1</Info>
<Info Type="Information2">This is Information2</Info>
</Infos>
<Users>
<UserDetails>
<Name>
<FirstName>Vipul</FirstName>
<MiddleName/>
<LastName>Malhotra</LastName>
</Name>
<DateOfBirth>12-Apr-1990</DateOfBirth>
</UserDetails>
</Users>
</Body>

Let’s break the creation of the file in two parts so as to be able to see more features.

We will first create the below Xml:

<?xml version="1.0" encoding="UTF-8"?>
<Parent>
<Header>
<FileDetails>
<FileName>RandomFile</FileName>
<FileVersion>1.0</FileVersion>
</FileDetails>
</Header>
<Body>
<Infos>
<Info Type="Information1">This is Information1</Info>
<Info Type="Information2">This is Information2</Info>
</Infos>
</Body>

In order to create this, we will first define an XDocument with the parent root as below:

XDocument doc = new XDocument(new XElement("Parent"));

After this, we will use this “doc” as the root of the file and will writing nested XElement to it.

Let’s first create the Header portion of the xml.
Header
Please notice that the XElement “Header “ is added as a new element and the further elements are added as nested to this “Header” element. It is due to the reason that the elements are sub-elements of “Header”. Further “FileName” and “FileVersion” element is a sub-element of “FileDetails”

In the same way, we would add another section to the root of the doc. This section would be “Body”.

The code for the same would be as:
code
This follows the same logic that “Body” is also sub-node of the root “parent” and so it is added directly to the root. Whereas , the element “Infos” is sub-element of “Body” and is so added in the way above. Same goes for “Info” which is a further sub-element of “Infos”.

Also notice how an attribute is added to each of the “Info” element using XAttribute.

After this, we further need to add the below section as sub-nodes of “Body” and not the root of the application:

<Users>
<UserDetails>
<Name>
<FirstName>Vipul</FirstName>
<MiddleName/>
<LastName>Malhotra</LastName>
</Name>
<DateOfBirth>12-Apr-1990</DateOfBirth>
</UserDetails>
</Users>

In order to do that, we would make sure that the code starts appending the code inside the “Body” tag of the already created xml.

Using XDocument, we can search for the node “Body” and then start adding node XElements to it .
node
Searching a node Is done using:

Further adding more elements to it is done using the below code:
code
The logic behind the hierarchy is the same as that discussed above.

The code can also be used inside a loop in case we need to add many similar sections to a particular node. Like in this case there can be many users and all of their details would have to be added in different UserDetails section inside the “Body” node.

Export An Excel Using Closed XML

Introduction

In today's tech world, most of the applications being developed under Logistics, Inventory, Internal Transaction and other domains require day-to-day data in excel files and prefer excel file operations in their applications.

I will be sharing one of the Nuget Package tools which, with very minimal lines of code, will export an excel file for us.

The Tool is Closed XML.

Just write a few lines of code and done! It is developer friendly. If we have used the Open XML, there are a lot of lines of code which are required to export an excel from data. We can create an excel file of 2007/2010 configuration without an Excel application.

To add the closed XML package, we add it directly through the user interface from the Nuget Gallery and also, we can use the Package Manager console to add the package using the below command

PM> Install-Package ClosedXML

Snippet

DataTable dt = new DataTable();
dt.Columns.AddRange(new DataColumn[3]
{
new DataColumn("Id", typeof(int)), new DataColumn("Name", typeof(string)), new DataColumn("Country", typeof(string))
});
dt.Rows.Add(1, "C Sharp corner", "United States");
dt.Rows.Add(2, "Suraj", "India");
dt.Rows.Add(3, "Test User", "France");
dt.Rows.Add(4, "Developer", "Russia"); //Exporting to Excel
string folderPath = "C:\\Excel\\";
if (!Directory.Exists(folderPath))
{
Directory.CreateDirectory(folderPath);
}
//Codes for the Closed XML
using (XLWorkbook wb = new XLWorkbook())
{
wb.Worksheets.Add(dt, "Customers");
//wb.SaveAs(folderPath + "DataGridViewExport.xlsx");
string myName = Server.UrlEncode("Test" + "_" + DateTime.Now.ToShortDateString() + ".xlsx");
MemoryStream stream = GetStream(wb);
// The method is defined below
Response.Clear();
Response.Buffer = true;
Response.AddHeader("content-disposition", "attachment; filename=" + myName);
Response.ContentType = "application/vnd.ms-excel";
Response.BinaryWrite(stream.ToArray());
Response.End();
}

The above code instantiates a data table, with few data initializations.

public MemoryStream GetStream(XLWorkbook excelWorkbook)
{
MemoryStream fs = new MemoryStream();
excelWorkbook.SaveAs(fs);
fs.Position = 0;
return fs;
}

We are using this method, so as to return a stream in order to download the file in response to using the stream. The save as method of the Closed XML helps create the stream.

Downloaded file looks like below,

file

Generating XML Root Node Having Colon-Via Serialization

Your comment on this post:

Related Articles