Generating XML Schema Dynamically Using VB.NET 2005: Essentials

There exist several articles on XML alone on this website.  If you are new to XML Schema, I strongly suggest you go through my series “Designing your own XML Schema.” That series will introduce you to all the necessary concepts in designing XML schemas, even if you are a beginner.

The entire solution for this article was developed using Visual Studio 2005 Professional Edition on Windows Server 2003 standard edition.  Some examples in this series may not compile successfully using Visual Studio 2003, as some of the features in .NET 1.1 turned out to be obsolete in .NET 2.0.  For complete details you can refer to the link http://go.microsoft.com/fwlink/?linkid=14202

Generating XML Schema dynamically using the .NET framework: preliminaries

Not everyone knows that we can generate XML schema dynamically using the .NET framework.  This happened to be the situation in one of my projects.  And I just wanted to share my knowledge with you.  I experienced few troubles when I ported my .NET 1.1 applications to .NET 2.0 (due to obsolescence).  During this series, we shall explore and address the most important issues on this topic.

First of all, we need to import two namespaces, namely “System.Xml” and “System.Xml.Schema”.  Both of them are available in the “System.Xml” assembly.  So, we need to refer (using “Add Reference”) to “System.Xml” before importing the two namespaces.

For this sample, I just created a simple Windows application using Visual Studio with a single button and multi-lined textbox.  When I hit the button it would generate some XML Schema in the multi-lined textbox.  So, I suggest you design the same before you proceed with the code.

Now let us consider that I would like to have the following XML Schema to be generated:

<?xml version="1.0" encoding="utf-16"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="Organization" type="xs:string" />
</xs:schema>

The above XML Schema simply declares a single element, “Organization.”  To generate the above XML Schema dynamically, copy and paste the following code and execute it with the application:

That’s it.  Just execute the application and hit the button. It will show the previous XML Schema in to the textbox.  You can find an explanation for the above code in the next section.

Understanding the dynamic generation of XML Schema using the .NET framework

This section explains the code fragment listed in the previous section.  Let us examine it part by part.  First consider the following:

The above makes class libraries (related to XML) available for our application.  We shall clear the textbox information using the following statement:

Proceeding further, we have the following statement:

The above statement really starts our XML Schema.  It creates an object (“schema”) of type “XmlSchema.”  The class “XmlSchema” basically exists in the namespace “System.Xml.Schema,” which resides in “System.XML.dll” assembly.  This would indirectly add the top most processing instruction, which defines the XML document version, and so on.

Once a schema object is created, we can start adding our own elements, attributes, processing instructions, comments, and so on to the same schema object.  Further proceeding, we have the following:

The above statement creates a simple XML Schema element (but no descriptions of the element yet!).  Further proceeding we have:

The first statement from the above code fragment adds the element “elementOrg” to the schema (which we already created at the top).  The second and third statements determine the characteristics of the element “elementOrg.”  The second statement assigns the element name and the third defines the “data type” with respect to the definitions available at http://www.w3.org/2001/XMLSchema.  Further proceeding, we have the following 

The above two statements are used to define the namespace to which our schema is adhered. Further proceeding we have the following:

The above code fragment creates a string writer where the schema is generated (using the namespace we defined earlier).  Once the schema generation is complete we finally display it using the last line.

Generating XML Schema dynamically using the .NET framework: complex type

Since I covered the basics in the previous sections, we shall now focus on “complex types” in XML Schema.  Generating “complex types” is a bit more complicated than generating “simple types.”  Let us consider the following XML Schema:

<?xml version="1.0" encoding="utf-16"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="Employee">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="ID" type="xs:int" />
        <xs:element name="Name" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

I know that the above XML schema is not at all practical.  But I will be using it only for demonstration.  I meant it only to explain the .NET code better (and not XML Schema).  To generate the above XML Schema dynamically, we can consider the following code:

I purposely excluded the “import” statements, as I already covered those in previous sections.  You can find the explanation of the above code in the next section.

Understanding the dynamic generation of complex type in XML Schema

This section explains the code fragment listed in the previous section.  Let us examine it part by part.  We shall clear the textbox information using the following statement:

Proceeding further, we have the following statement:

The above statement starts our XML Schema.  Once a schema object is created, we can start adding our own elements, attributes, processing instructions, comments, and so on to the same schema object.  Further proceeding, we have the following: 

The above code fragment simply creates a new element called “Employee” and adds it to the schema generator.  Further proceeding we have:

As “Employee” is of the “complex type” (and not “simple type”), we need to specify this point.  A complex type should also be joined with a “particle.”  The “particle” could be any of “All,” “Sequence,” “Choice” and so on (which I already explained in my “Designing your own XML Schema” Series). 

The above code fragment creates a new complex type (for the “Employee” element) and a “sequence particle” (which means that the elements should be provided in an orderly fashion).  Further proceeding, we have the following:

A “particle” generally contains the nested elements inside it (not every particle may contain nested elements as well).  In our case, the “Employee” element needs to be nested with two more elements (child elements), “ID” and “Name.” 

The above code fragment creates a new element, names it “ID,” defines it as an integer data type, and finally adds it to the “sequence particle.”  Similarly, we add the “Name” element as follows:

Further proceeding, we have the following

The above two statements are used to define the namespace to which our schema gets adhered.  Proceeding further we have the following:

The above code fragment creates a string writer where the schema is generated (using the namespace we defined earlier).  Once the schema generation is complete we finally display it using the last line.

I hope that this article gives you a kick-start in generating dynamic XML Schemas using the .NET framework.  Another issue to pay attention to is that the examples I used in this demonstration may not be helpful in practical (or production) scenarios.  I strongly suggest you have a proper working draft design of the XML Schema you wanted to generate, and finally generate it using the code I present in this series.  A working draft may not be necessary if you want to generate the XML Schema from existing relational databases or other, similar kinds of structured information sources.

Any comments, suggestions, feedback, bugs, errors, enhancements are highly appreciated at jag_chat@yahoo.com