Hi,

A post with concrete examples concerning the generation of Types/POJO from a XSD file, the serialization of these objects/POJO to XML and finally the validation of XML with XSD.

Generate Custom Types from XSD file

• XSD file myXsdFile.xsd:

  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
              targetNamespace="urn:books"
              xmlns:bks="urn:books">
  
    <xsd:element name="books" type="bks:BooksForm"/>
  
    <xsd:complexType name="BooksForm">
      <xsd:sequence>
        <xsd:element name="book"
                    type="bks:BookForm"
                    minOccurs="0"
                    maxOccurs="unbounded"/>
      </xsd:sequence>
    </xsd:complexType>
  
    <xsd:complexType name="BookForm">
      <xsd:sequence>
        <xsd:element name="author"   type="xsd:string"/>
        <xsd:element name="title"    type="xsd:string"/>
        <xsd:element name="genre"    type="xsd:string"/>
        <xsd:element name="price"    type="xsd:float" />
        <xsd:element name="pub_date" type="xsd:date" />
        <xsd:element name="review"   type="xsd:string"/>
      </xsd:sequence>
      <xsd:attribute name="id"   type="xsd:string"/>
    </xsd:complexType>
  </xsd:schema>
  

   

• CSharp sources and types generator:

          /// <summary>
          /// Custom Types Generator from XSD file
          /// </summary>
          /// <param name="xsdFile"></param>
          /// <param name="outputFile"></param>
          private static bool generateCSharpFile(string xsdFile, string outputFile)
          {
              bool result = true;
              try
              {
                  var stream = new MemoryStream(File.ReadAllBytes(xsdFile));
  
                  var schema = XmlSchema.Read(XmlReader.Create(stream), null);
                  var schemas = new XmlSchemas();
                  schemas.Add(schema);
  
                  var ns = new CodeNamespace { Name = "books" };
                  ns.Imports.Add(new CodeNamespaceImport("System"));
                  ns.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
  
                  var exporter = new XmlCodeExporter(ns);
                  var importer = new XmlSchemaImporter(schemas);
  
                  foreach (XmlSchemaElement element in schema.Elements.Values)
                  {
                      var mapping = importer.ImportTypeMapping(element.QualifiedName);
                      exporter.ExportTypeMapping(mapping);
                  }
  
                  // Transform CodeDOM as required, adding new attributes, methods, modifying
                  // inheritance hierarchy, whatever.
                  var provider = new CSharpCodeProvider();
  
                  using (var writer = new StreamWriter(outputFile, false))
                  {
                      // Creates a new CodeGeneratorOptions.
                      CodeGeneratorOptions genOptions = new CodeGeneratorOptions();
  
                      // Sets a value indicating that the code generator should insert blank lines between type members.
                      genOptions.BlankLinesBetweenMembers = true;
  
                      // Sets the style of bracing format to use: either "Block" to start a
                      // bracing block on the same line as the declaration of its container, or 
                      // "C" to start the bracing for the block on the following line.
                      genOptions.BracingStyle = "C";
  
                      // Sets a value indicating that the code generator should not append an else, 
                      // catch or finally block, including brackets, at the closing line of a preceeding if or try block.
                      genOptions.ElseOnClosing = false;
  
                      // Sets the string to indent each line with.
                      genOptions.IndentString = "    ";
  
                      // Uses the CodeGeneratorOptions indexer property to set an
                      // example object to the type's string-keyed ListDictionary.
                      // Custom ICodeGenerator implementations can use objects 
                      // in this dictionary to customize process behavior.
                      genOptions["CustomGeneratorOptionStringExampleID"] = "BuildFlags: /A /B /C /D /E";
  
                      provider.GenerateCodeFromNamespace(ns, writer, genOptions);
                  }
              }
              catch (Exception ex)
              {
                  Console.Write(ex.ToString());
                  result = false;
              }
  
              return result;
          }
  
  

  //….

              string xsdFile = "C:\\Workspaces\\MS_Visual_Studio_Projects\\TestApps\\TestXmlXsd1\\myXsdFile.xsd";
              string outputFile = "C:\\Workspaces\\MS_Visual_Studio_Projects\\TestApps\\TestXmlXsd1\\generated\\MyCustomTypes.cs";
  
              generateCSharpFile(xsdFile, outputFile);
  

   
   

• After execution, a CSharp file MyCustomTypes.cs containing all types of XSD file is generated:

  namespace books
  {
      using System;
      using System.Collections.Generic;
      
      
      /// <remarks/>
      [System.CodeDom.Compiler.GeneratedCodeAttribute("TestXmlXsd1", "1.0.0.0")]
      [System.SerializableAttribute()]
      [System.Diagnostics.DebuggerStepThroughAttribute()]
      [System.ComponentModel.DesignerCategoryAttribute("code")]
      [System.Xml.Serialization.XmlTypeAttribute(Namespace="urn:books")]
      [System.Xml.Serialization.XmlRootAttribute("books", Namespace="urn:books", IsNullable=false)]
      public partial class BooksForm
      {
          
          private BookForm[] bookField;
          
          /// <remarks/>
          [System.Xml.Serialization.XmlElementAttribute("book", Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
          public BookForm[] book
          {
              get
              {
                  return this.bookField;
              }
              set
              {
                  this.bookField = value;
              }
          }
      }
      
      /// <remarks/>
      [System.CodeDom.Compiler.GeneratedCodeAttribute("TestXmlXsd1", "1.0.0.0")]
      [System.SerializableAttribute()]
      [System.Diagnostics.DebuggerStepThroughAttribute()]
      [System.ComponentModel.DesignerCategoryAttribute("code")]
      [System.Xml.Serialization.XmlTypeAttribute(Namespace="urn:books")]
      public partial class BookForm
      {
          
          private string authorField;
          
          private string titleField;
          
          private string genreField;
          
          private float priceField;
          
          private System.DateTime pub_dateField;
          
          private string reviewField;
          
          private string idField;
          
          /// <remarks/>
          [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
          public string author
          {
              get
              {
                  return this.authorField;
              }
              set
              {
                  this.authorField = value;
              }
          }
          
          /// <remarks/>
          [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
          public string title
          {
              get
              {
                  return this.titleField;
              }
              set
              {
                  this.titleField = value;
              }
          }
          
          /// <remarks/>
          [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
          public string genre
          {
              get
              {
                  return this.genreField;
              }
              set
              {
                  this.genreField = value;
              }
          }
          
          /// <remarks/>
          [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
          public float price
          {
              get
              {
                  return this.priceField;
              }
              set
              {
                  this.priceField = value;
              }
          }
          
          /// <remarks/>
          [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified, DataType="date")]
          public System.DateTime pub_date
          {
              get
              {
                  return this.pub_dateField;
              }
              set
              {
                  this.pub_dateField = value;
              }
          }
          
          /// <remarks/>
          [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
          public string review
          {
              get
              {
                  return this.reviewField;
              }
              set
              {
                  this.reviewField = value;
              }
          }
          
          /// <remarks/>
          [System.Xml.Serialization.XmlAttributeAttribute()]
          public string id
          {
              get
              {
                  return this.idField;
              }
              set
              {
                  this.idField = value;
              }
          }
      }
  }
  
  

Serialization of objects to XML

• Instantiation of POJO objects and use of them in order to generate XML file myXmlFile.xml:

          /// <summary>
          /// Generate XML file for POJO annotated (System.Xml)
          /// </summary>
          /// <param name="model"></param>
          /// <param name="xmlFile"></param>
          private static bool generateXML(object model, string xmlFile)
          {
              bool result = true;
              try
              {
                  // Build POJO
                  var serializer = new XmlSerializer(model.GetType());
  
                  using (StreamWriter writer = new StreamWriter(xmlFile, true, new UTF8Encoding(false)))
                  {
                      serializer.Serialize(writer, model);
                  }
              }
              catch (XmlSchemaValidationException ex)
              {
                  Console.Write(ex.ToString());
                  result = false;
              }
  
              return result;
          }
  

  //….

              string xmlGeneratedFile = "C:\\Workspaces\\MS_Visual_Studio_Projects\\TestApps\\TestXmlXsd1\\myXmlFile.xml";
              BooksForm booksForm = new BooksForm();
              {
                  List<BookForm> booksList = new List<BookForm>();
                  {
                      BookForm book = new BookForm();
                      book.id = "bk001";
                      book.author = "Writer";
                      book.title = "The First Book";
                      book.genre = "Fiction";
                      book.price = 44.95F;
                      book.pub_date = DateTime.ParseExact("2000-10-01", "yyyy-MM-dd", CultureInfo.InvariantCulture);
                      book.review = "An amazing story of nothing.";
                      booksList.Add(book);
                  }
                  {
                      BookForm book = new BookForm();
                      book.id = "bk002";
                      book.author = "Poet";
                      book.title = "The Poet's First Poem";
                      book.genre = "Poem";
                      book.price = 24.95F;
                      book.review = "Least poetic poems.";
                      booksList.Add(book);
                  }
                  booksForm.book = booksList.ToArray();
              }
  
  
              generateXML(booksForm, xmlGeneratedFile);
  

   
   

• The generated XML file myXmlFile.xml would be:

  <?xml version="1.0" encoding="utf-8"?>
  <books xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="urn:books">
    <book id="bk001" xmlns="">
      <author>Writer</author>
      <title>The First Book</title>
      <genre>Fiction</genre>
      <price>44.95</price>
      <pub_date>2000-10-01</pub_date>
      <review>An amazing story of nothing.</review>
    </book>
    <book id="bk002" xmlns="">
      <author>Poet</author>
      <title>The Poet's First Poem</title>
      <genre>Poem</genre>
      <price>24.95</price>
      <pub_date>0001-01-01</pub_date>
      <review>Least poetic poems.</review>
    </book>
  </books>
  

Validation of XML with XSD file

• Validation of generated XML myXmlFile.xml with original XSD file myXsdFile.xml:

          /// <summary>
          /// Validate XML file with XSD file
          /// </summary>
          /// <param name="xmlFilePath"></param>
          /// <param name="xsdFilePath"></param>
          /// <param name="namespaceName"></param>
          /// <returns></returns>
          private static bool IsValidXml(string xmlFilePath, string xsdFilePath, string namespaceName)
          {
              var xdoc = XDocument.Load(xmlFilePath);
              var schemas = new XmlSchemaSet();
              schemas.Add(namespaceName, xsdFilePath);
  
              bool result = true;
              try
              {
                  xdoc.Validate(schemas, (sender, e) =>
                  {
                      Console.Write("Error:" + e.Message);
                      result = false;
                  });
              }
              catch (XmlSchemaValidationException ex)
              {
                  Console.Write(ex.ToString());
                  result = false;
              }
              return result;
          }
  

  //….

              string xsdFile = "C:\\Workspaces\\MS_Visual_Studio_Projects\\TestApps\\TestXmlXsd1\\myXsdFile.xsd";
              string xmlGeneratedFile = "C:\\Workspaces\\MS_Visual_Studio_Projects\\TestApps\\TestXmlXsd1\\myXmlFile.xml";
  
              IsValidXml(xmlGeneratedFile, xsdFile, "urn:books");
  

Note: Below the import / using needed to these methods:

using Microsoft.CSharp;
using System;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.IO;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Schema;
using System.Xml.Serialization;
using System.Text;
using books;
using System.Collections.Generic;
using System.Globalization;

Best regards,

Huseyin OZVEREN