Unit testing WCF data contract serialization.

PeterRitchie — Tue, 05 May 2009 02:30:00 GMT

WCF service define "data contracts" for their interfaces. These contracts are often defined in an XML schema document and used to generated WCF data contract code. This process effectively creates a .NET type that will serialize to a chunk of XML text.

Depending on the operation of the WCF service, its code may be responsible for creating some of these objects. A return value from an operation, for example. While the framework handles XML serialization of these object behind the scenes. But, if your have complex types and you end up not setting all the properties correctly in your object tracking down what properties haven't been set properly can be a chore as the server would have to enable passing exceptions back to the client, etc.

A technique that I've found useful is to add unit tests to ensure the creation of my contract objects are indeed serializable.

For example, I may have an method GetCustomer that retrieves a customer. Where I would like to create this contract Customer I would create a method to create this contract object based on parameters, like a Model Customer object.

For example:

    PRI.ExampleWcfService.Customer ToWcfContractCustomer(PRI.Model.Customer customer)
    {
        //...
    } 

Now, one of the unit tests would call this method and attempt to serialize the object to XML text, for example:

    [Test]
    public void WhenCreatingCustomerContract_EnsureXmlSerializationSucceeds()
    {
        PRI.ExampleWcfService.Model.Customer customer = CustomerRepository.Get(1);
        PRI.ExampleWcfService.Application.Customer contractCustomer = ToWcfContractCustomer(customer);
        String text = Utility.ContractObjectToXml(contractCustomer);
    } 

where Utility.ContractObjectToXml is declared as:

    public static class Utility
    {
        public static string ContractObjectToXml<T>(T obj)
        {
            DataContractSerializer dataContractSerializer = new DataContractSerializer(obj.GetType());
 
            String text;
            using (MemoryStream memoryStream = new MemoryStream())
            {
                dataContractSerializer.WriteObject(memoryStream, obj);
                byte[] data = new byte[memoryStream.Length];
                Array.Copy(memoryStream.GetBuffer(), data, data.Length);
 
                text = Encoding.UTF8.GetString(data);
            }
            return text;
        }
    }

Now, when this unit test is run, it will fail if the serialization process throws an exception because the resulting XML would violate the schema.

See [DataContractSerializer.ReadObject is easily confused] for why I'm creating a new buffer and copying the serialized data before converting it to a string.

DataContractSerializer.ReadObject is easily confused.

PeterRitchie — Thu, 30 Apr 2009 02:14:41 GMT

With WCF services you need to declare contracts and generate contract classes that encapsulate those contracts. Most of the time you can simply let the framework deal with whatever it needs to do to deal with these objects. Sometimes, you need to actually see without running a service what XML would result from a contract object or serialize a contract object from XML text.

In .NET 3.5 there exists the System.Runtime.Serialization.DataContractSerializer class that perform serialization of data contracts.

Based on its documentation it seems fairly simple to create data contract object to/from XML methods. For example:

    public static T XmlToContractObject<T>(string xml) where T : class, IExtensibleDataObject
    {
        MemoryStream memoryStream = new MemoryStream(Encoding.Unicode.GetBytes(xml));
        using (
        XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(memoryStream, Encoding.Unicode,
                   new XmlDictionaryReaderQuotas(), null))
        {
            DataContractSerializer dataContractSerializer = new DataContractSerializer(typeof(T));
            return dataContractSerializer.ReadObject(reader) as T;
        }
    }
 
    public static string ContractObjectToXml<T>(T obj) where T : IExtensibleDataObject
    {
        DataContractSerializer dataContractSerializer = new DataContractSerializer(obj.GetType());
 
        String text;
        using (MemoryStream memoryStream = new MemoryStream())
        {
            dataContractSerializer.WriteObject(memoryStream, obj);
 
            text = Encoding.UTF8.GetString(memoryStream.GetBuffer());
        }
        return text;
    }

But, when you try to perform a round-trip from a contract object to XML and back you'll notice that you get SerializationException with the cryptic message of "There was an error deserializing the object of type <sometype>. The data at the root level is invalid", despite that the XML seems view when examined.

When Encoding.UTF8.GetString is called, it literally translates the entire array into a String object. This means that it reads any and all 0 bytes in the array and dumps out null characters ('\0') into the string. Why do I mention this? Well, MemoryStream uses a self-expanding buffer to write to. When MemoryStream runs out of space in its buffer, it doubles the size of the buffer, zeroes it out, then copies the original buffer to the start of the new buffer. When MemoryStream.GetBuffer is called it simply gets a reference to this buffer, regardless of how many bytes have been written to the stream. So, most of the time you get a buffer with zeroes padded to the end of it.

If you look closely at the resulting XML, there are a bunch of '\0' characters at the end of the string.

As it turns out, DataContractSerializer.ReadObject (or something it calls) doesn't like all the extra null characters and this is the cause of the SerializationException.

Irritating as this may be, the fix is fairly straightforward. Simply, create a new buffer equal to the length of the stream and copy the data from the MemoryStream buffer to the new one--trimming all the extra zeroes. For example:

    public static string ContractObjectToXml<T>(T obj) where T : IExtensibleDataObject
    {
        DataContractSerializer dataContractSerializer = new DataContractSerializer(obj.GetType());
 
        String text;
        using (MemoryStream memoryStream = new MemoryStream())
        {
            dataContractSerializer.WriteObject(memoryStream, obj);
            byte[] data = new byte[memoryStream.Length];
            Array.Copy(memoryStream.GetBuffer(), data, data.Length);
 
            text = Encoding.UTF8.GetString(data);
        }
        return text;
    }

Peter Ritchie's MVP Blog : WCF

Unit testing WCF data contract serialization.

DataContractSerializer.ReadObject is easily confused.