LINQ

There are many ways to build XML documents but the main approach I have used in the past was to build an object model and leverage serialization.  This approach was effective but costly in terms of serialization time and complexity of building the objects.  I have previously blogged about using LINQ to XML to transform and parse NIEM XML documents but have not written about generating NIEM XML with LINQ.

For a new project at REJIS we were updating an existing interface to use NIEM XML.  After some discussion with Sudhir Umarji I chose to use a pre-built N-Dex Booking IEPD. This provided the base with all the elements we would need to exchange.  One of our senior developers began working with me to create a new service based solution. 

Because we generally have a "vertical" market for our services we tend to build the service and the client.  The approach we use is that the service returns the format that makes the most sense, which is always one of our domain object structures; a very simple object model for all the different documents and data elements we work with.  The client uses a factory/adapter pattern where the adapters implement an interface and then through configuration we specify the concrete adapter to use at runtime.  In code we create the instance using System.Activator.  This gives us the most flexibility with outputting to different formats, databases, etc.  One of our services using this pattern has three adapters in production and all are called from the same client program.

For this new service endeavor we would be using a similar approach but this time we would be using an adapter to transform records into the N-Dex Booking IEPD format.  For this adapter I wanted to try generating the XML with LINQ.  Since we work in VB.NET we have the advantage of using XML literals which turned out to be a pretty useful way for us to generate NIEM XML.  It allows us to visually see the document we would be creating and break it into manageable chunks to control the output.

The problems encountered mostly revolved around managing the IDs and creating the associations as well as guarding against null elements in our object model and preventing them from outputting malformed XML.  We also had to look a little into how to handle "for each" loops.  This can be accomplished by using an embedded expression such as "<%= From person in MyRecord.People Select BuildPersonElement(person)%>" (Imagine here that BuildPersonElement takes a person object and outputs the appropriate XML). 

Some tips:

• Identify the static parts of your document and break those into separate methods.
• A lot of structures in NIEM are very repeatable, identify those, and provide methods to assist in building them.
• Use good defensive programming in your methods to protect yourself from nulls.  If your methods do not have all the required data elements to build the XML structure simply return nothing (unless it makes sense to throw an exception).
• Identify all your element IDs that will need to be created and manage those with lists.
• Use the VB.Net Import xmlns statements to import all your namespaces into your code file.  This will help LINQ keep the namespaces prefixed and reduce the size of your XML.
• If you bring the schemas into one of the studio projects you can use that to get intellisense.  For N-Dex based schemas this may not work because separate schemas that reference the same namespaces are used for the digest and structured content.  We included the digest schemas and used studio to validate our XML instances.