top button
Flag Notify
    Connect to us
      Facebook Login
      Site Registration Why to Join

    Get Free Article Updates

Facebook Login
Site Registration

Generating XML Root Node Having Colon-Via Serialization

0 votes
23 views

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.

 

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

Below are the classes I created for serialization purposes.

  1. public class RandomWindow    
  2. {    
  3.     [XmlAttribute(Form=System.Xml.Schema.XmlSchemaForm.Qualified, Namespace="http://www.w3.org/2001/XMLSchema-instance")]    
  4.     public string schemaLocation {get;set;}    
  5.     
  6.     [XmlElement]    
  7.     public string Title {get;set;}    
  8.     
  9.      [XmlElement]    
  10.      public string Border {get;set;}    
  11. }    

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

  1. <?xml version="1.0" encoding="UTF-8"?>   
  2. <RandomWindow xsi:schemaLocation="" xmlns:sl="" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">    
  3. <Title>First Window</Title>    
  4. <Border>Single</Border>    
  5. </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 -

 

  1. [XmlRoot("sl:RandomWindow")]  
  2. 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.

 

  1. [XmlRoot("RandomWindow", Namespace = "")]  
  2. 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.

  1. [XmlRoot("RandomWindow", Namespace="")]    
  2. public class RandomWindow      
  3. {      
  4.     [XmlAttribute(Form=System.Xml.Schema.XmlSchemaForm.Qualified, Namespace="http://www.w3.org/2001/XMLSchema-instance")]      
  5.     public string schemaLocation {get;set;}      
  6.       
  7.     [XmlElement(Namespace=" ")]      
  8.     public string Title {get;set;}      
  9.       
  10.      [XmlElement(Namespace=" ")]     
  11.      public string Border {get;set;}      
  12. }    

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

  1. <?xml version="1.0" encoding="UTF-8"?>      
  2. <sl:RandomWindow xsi:schemaLocation="" xmlns:sl="" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">      
  3. <Title xmlns=" ">First Window</Title>      
  4. <Border xmlns=" ">Single</Border>      
  5. </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 !!!

posted Jan 10 by Shivaranjini

  Promote This Article
Facebook Share Button Twitter Share Button Google+ Share Button LinkedIn Share Button Multiple Social Share Button


Related Articles

                                                                                                                                     

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.

READ MORE

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:

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <Parent>  
  3. <Header>  
  4. <FileDetails>  
  5. <FileName>RandomFile</FileName>  
  6. <FileVersion>1.0</FileVersion>  
  7. </FileDetails>  
  8. </Header>  
  9. <Body>  
  10. <Infos>  
  11. <Info Type="Information1">This is Information1</Info>  
  12. <Info Type="Information2">This is Information2</Info>  
  13. </Infos>  
  14. <Users>  
  15. <UserDetails>  
  16. <Name>  
  17. <FirstName>Vipul</FirstName>  
  18.  <MiddleName/>  
  19.                     <LastName>Malhotra</LastName>  
  20.                 </Name>  
  21. <DateOfBirth>12-Apr-1990</DateOfBirth>  
  22. </UserDetails>  
  23. </Users>  
  24. </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:

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <Parent>  
  3. <Header>  
  4. <FileDetails>  
  5. <FileName>RandomFile</FileName>  
  6. <FileVersion>1.0</FileVersion>  
  7. </FileDetails>  
  8. </Header>  
  9. <Body>  
  10. <Infos>  
  11. <Info Type="Information1">This is Information1</Info>  
  12. <Info Type="Information2">This is Information2</Info>  
  13. </Infos>  
  14. </Body>  

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

  1. 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:

  1. <Users>  
  2. <UserDetails>  
  3. <Name>  
  4. <FirstName>Vipul</FirstName>  
  5.  <MiddleName/>  
  6.                     <LastName>Malhotra</LastName>  
  7.                 </Name>  
  8. <DateOfBirth>12-Apr-1990</DateOfBirth>  
  9. </UserDetails>  
  10. </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.

READ MORE

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

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

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

  1. public MemoryStream GetStream(XLWorkbook excelWorkbook)   
  2. {  
  3.     MemoryStream fs = new MemoryStream();  
  4.     excelWorkbook.SaveAs(fs);  
  5.     fs.Position = 0;  
  6.     return fs;  
  7. }

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

READ MORE
Contact Us
+91 9880187415
sales@queryhome.net
support@queryhome.net
#280, 3rd floor, 5th Main
6th Sector, HSR Layout
Bangalore-560102
Karnataka INDIA.
QUERY HOME
...