What is the best way to create an XML document conforming to an XSD Schema?

Question

I have an XSD and I have to generate an XML document to send to the customers of the company I work with. The documents I send will be validated against this XSD schema.

What is the best way to create a XML document conforming to a XSD Schema? I mean, I'm searching for best practices and the like. I'm new to this and while "Googling" around here and there, I found people using XmlTextWriter, DataSet.WriteXml, and others.

1. DataSet.WriteXml seems to not work well for me. This is what I did:

   var ds = new DataSet();
   ds.ReadXmlSchema(schemaFile);
   ds.Tables["TableName"].Rows.Add("", "", 78, true, DateTime.Now);
   ...
   ds.WriteXml("C:\\xml.xml");
   

   I found it generates a node with NewDataSet, and the nodes are not in the proper order.

2. XmlTextWriter, I find it a bit long to do... but I will if there is no other choice.

What do you think is the best way to do this? Are there other approaches to do it? I would put the schema here if it wasn't so long, and if it were relevant to the question.

Answer 1

Such a great reference .. http://msdn.microsoft.com/en-us/library/x6c1kb0s%28v=vs.110%29.aspx

I just generated classes with fields for csharp:

First you open visual studio command prompt (programs->visualStudio->visualstudioTools->VisualstudioCommandPrompt)

Then you change to the directory of your xsd file and then run the following command:

xsd /classes /fields /language:CS MyXSDSCHEMAFILE.xsd

(replace the MyXSDSCHEMAFILE.xsd with your xsd file name)

After your cs file is created, copy it into your project folder where all the other cs file are and add it to the project in visual studio by right clicking the project and adding existing item. Once that is completed go to your code segment where you want to use your class and initialize like this (classname is the class that was created in the cs file):

classname myvariablename = new classname(); // so easy :)
// now you just fill with content
myvariablename.whatever.andever.field = "JaWerHatDasErfunden";// you just set a field

then serialize as xml (tons of examples on the web )

Useful Hint: Be aware that instantiation is not always part of the xsd created classes.
Make sure you create your objects properly to avoid Null Pointer exceptions.

Answer 2

The mainstream practice in .NET is to use XML Serialization.

In your case, I would do this:

• run the xsd.exe too on .XSD to generate source code for classes (xsd /c)
• build your app that utilizes those generated classes. Keep in mind you can extend those classes via the "partial classes" technique
• in code, instantiate an XmlSerializer, and Serialize the class instances.

Example:

Given this schema:

<xs:schema elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="Foo" nillable="true" type="Foo" />
  <xs:complexType name="Foo">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="1" name="Bar" type="xs:string" />
      <xs:element minOccurs="0" maxOccurs="1" name="Baz" type="UntypedArray" />
    </xs:sequence>
  </xs:complexType>


  <xs:complexType name="UntypedArray">
    <xs:choice minOccurs="1" maxOccurs="unbounded">
      <xs:element name="Type1" type="Type1"                 minOccurs="1" maxOccurs="1"/>
      <xs:any     namespace="##other" processContents="lax" minOccurs="1" maxOccurs="1"/>
    </xs:choice>
  </xs:complexType>


  <xs:complexType name="Type1" mixed="true">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="1" name="Child" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
</xs:schema>

xsd.exe generates this source code:

[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "2.0.50727.42")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlRootAttribute(Namespace="", IsNullable=true)]
public partial class Foo {

    private string barField;

    private object[] bazField;

    /// <remarks/>
    public string Bar {
        get {
            return this.barField;
        }
        set {
            this.barField = value;
        }
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlArrayItemAttribute("", typeof(System.Xml.XmlElement), IsNullable=false)]
    [System.Xml.Serialization.XmlArrayItemAttribute(typeof(Type1), IsNullable=false)]
    public object[] Baz {
        get {
            return this.bazField;
        }
        set {
            this.bazField = value;
        }
    }
}

/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "2.0.50727.42")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
public partial class Type1 {

    private string childField;

    private string[] textField;

    /// <remarks/>
    public string Child {
        get {
            return this.childField;
        }
        set {
            this.childField = value;
        }
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlTextAttribute()]
    public string[] Text {
        get {
            return this.textField;
        }
        set {
            this.textField = value;
        }
    }
}

In your app you can instantiate a Foo and then serialize, like this:

    Foo foo = new Foo();
    // ...populate foo here...
    var builder = new System.Text.StringBuilder();
    XmlSerializer s = new XmlSerializer(typeof(Foo));
    using ( var writer = System.Xml.XmlWriter.Create(builder))
    {
        s.Serialize(writer, foo, ns);
    }
    string rawXml = builder.ToString();

This example serializes into a string. Of course you can serialize to other XmlWriters, you can write out to a file, to any arbitrary stream, and so on.

Normally I tweak the serialization to omit the XML declaration, omit the default xml namespaces, and so on. Like this:

    Foo foo = new Foo();
    // ...populate foo here...
    var builder = new System.Text.StringBuilder();
    var settings = new System.Xml.XmlWriterSettings { OmitXmlDeclaration = true, Indent= true };
    var ns = new XmlSerializerNamespaces();
    ns.Add("","");
    XmlSerializer s = new XmlSerializer(typeof(Foo));
    using ( var writer = System.Xml.XmlWriter.Create(builder, settings))
    {
        s.Serialize(writer, foo, ns);
    }
    string rawXml = builder.ToString();

You can also do the reverse - map from an XML document to an in-memory object graph - using the XmlSerializer. Use the Deserialize method.

Answer 3

You can create the XML and then run it through an Xml Schema Validator that I wrote.

Answer 4

A post I wrote a while ago may be of interest to you. I had to work with BizTalk and found that generating my classes from an XSD and then serializing that class over the wire (wa-la XML) worked quite well!

http://blog.andrewsiemer.com/archive/2008/04/30/accepting-xmldocuments-from-biztalk-de-serializing-them-to-xsd-generated-serializable.aspx

This allows you to work with the data as a class and all the perks that go along with that. And it totally allows you to bypass the XML writers!