Chris May

Have you ever wanted to validate an xml document against a schema, but didn't have any applications at your disposal to do it?

You can use the schema validate tool on decisionsoft.com:

http://tools.decisionsoft.com/schemaValidate/

You upload a schema and an xml doc, and it will attempte to validate the xml against the schema.

Here is a cheat sheet that shows some of the main items when using Regular Expressions (RegEx / RegExp)

regular_expressions_cheat_sheet[1].png (80.91 KB)

.Net has a tool called the XML Schema Definition Tool (XSD.EXE) which can turn XSD schemas into classes.  Also, it will try to make it so those classes will conform to the schema when serialized as XML.

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cptools/html/cpconxmlschemadefinitiontoolxsdexe.asp

xsd.exe pathToXSD.xsd /classes /language:VB /outputdir:C:\output

You can then serialize and deserialize the object into/from XML.

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemXmlSerializationXmlSerializerClassTopic.asp

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemXmlSerializationXmlSerializerClassDeserializeTopic.asp

 

 

It seems like validating an XML document against a schema would be a pretty simple thing to do in the .Net framework, seeing as how they have such deep support for dealing with XML.

But as of yet, I haven't found a simple way to do it.

Here is the code I have been using to validate XML against an XML Schema.

Imports System.IO
Imports System.Xml
Imports System.Xml.Schema


    Private schemaValidation As New ValidationEventHandler(AddressOf ValidationHandler)

    Private Function ValidateXml(ByVal xmlFileName As String, ByVal xmlSchemaName As String) As Boolean
        Using myFile As New FileStream(xmlFileName, FileMode.Open, FileAccess.Read, FileShare.None)
            Dim xDoc As New Xml.XmlDocument()
            xDoc.Load(myFile)
            xDoc.Schemas.Add(GetSchema(xmlSchemaName))
            Try
                xDoc.Validate(schemaValidation)
                Return True
            Catch ex As XmlSchemaValidationException
                Console.Write(ex.ToString)
                Return False
            Catch ex As XmlSchemaException
                Console.Write(ex.ToString)
                Return False
            Catch ex As Exception
                Console.Write(ex.ToString)
                Return False
            End Try
        End Using
    End Function

    Private Function GetSchema(ByVal filePath As String) As XmlSchema
        Dim schema As XmlSchema
        Using s As New System.IO.FileStream(filePath, FileMode.Open)
            Using reader As New StreamReader(s)
                schema = XmlSchema.Read(reader, Nothing)
            End Using
        End Using
        Return schema
    End Function

    Private Sub ValidationHandler(ByVal sender As Object, ByVal e As System.Xml.Schema.ValidationEventArgs)
        Throw e.Exception
    End Sub

I have tried to councel against sending datasets across web service calls, but we have a lot of instances where this is being done.

One of the problems with this is that datasets get bloated when converted to XML.

So I set out to compare the sizes of:

1. Serialized List(Of MyType)
2. Serialized DataTable
3. Serialized DataSet
4. XML Serialized Dataset

I wish I had done some research on this, because I would have quickly been reminded that DataSets always serialize as XML, even if you are using the BinaryFormatter. 

There are lots of people out there coming up with their own ideas for how to improve the serialization of datasets:

• Dino Esposito's Ghost method
• MSDN Surrogate Dataset Serialization
• Andres Aguiar's Customization of Generated DataSets
• Another Ariticle Summing Up Other Options

Anyway, this isn't really THAT big of a deal, because my real goal wasn't to improve the dataset serialization, but to simply see what it would be, and compare it to some other ways to serialize data, like in a list of business objects or a datatable.

The results are interesting:

Given a list of 1013 Business Objects (Records) the serialization results are as follows:

Method	Size (bytes)
List(Of MyType)	290,321
DataTable	819,575
DataSet	693,088
XML Serialzied Dataset	851,614

I have read that you can really decrease the size of the dataset by writing your own logic to do the serialization, but as everyone points out that is kind of a pain.

This article shows how to send data as an xml/html Excel document. The user can then view it in IE, or choose to edit it in Excel (all functions come along when you do the Excel editing.

This article describes how to use XML Serialization to persist objects.

This is the only article on XML Serialization that I have found that shows how to convert the object into a string rather than a file on the hard drive.

It was a pain in the butt trying to find this. Ok, well it wasn't THAT hard, but I didn't expect it to be so buried on the MSDN site, and of course their search features totally suck.

Here is the MSXML XML DOM Reference page from MSDN.