Patrick's SharePoint Blog

SharePoint's Booming world

XMLFormatter provider for serialization

Posted by Patrick Boom on September 2, 2010

Introduction

(This article was published by myself on CodePlex in 2006. Moved it here)

During the development process of our project, the need arose to serialize objects to XML. For this purpose, the .NET provides the XmlSerializer class to serialize objects. This class has some disadvantages, however.

First, the creation of the class is expensive in performance. This is caused by the fact the class creates an in-memory assembly to quickly read and write from the objects to serialize. It does this by using reflection to inspect the object. This leads to the second disadvantage; only public properties and fields are serialized. These properties also have to be writable so that the XmlSerializer can set the properties during deserialization. This leads to problems encapsulating your code. Finally, but not less important, it does not support the ISerializable interface.

Alternatives

To get around these problems, you can use the SoapFormatter class to serialize the object to SOAP. This class does support the ISerializable interface, and does not use reflection. The resulting XML, however, is less accessible than the plain XML the XmlSerializer produces, and has a lot of overhead. The only thing left is to create your own formatter by implementing the IFormatter interface.

XmlFormatter

The code accompanied by this article contains our XmlFormatter class that has the following features:

  • Produces more clean XML than the SOAP structure of the SoapFormatter
  • Supports the ISerializable interface
  • Does not impact performance by creating in-memory assemblies

The following example shows the use of the formatter, by serializing a class called MyObject:

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Serialization;
namespace XmlFormatterSample
{
[Serializable]
public class MyObject : ISerializable
{
   public string MyPublicProperty
  
{
      get { return _myPublicProperty; }

      set { _myPublicProperty = value; }
  
}
   private string _myPublicProperty;

   private string MyPrivateProperty
  
{
      get { return _myPrivateProperty; }

      set { _myPrivateProperty = value; }
  
}
   private string _myPrivateProperty;

  
   public
MyObject()
  
{
      this._myPublicProperty = “This is my public property”;

      this._myPrivateProperty = “This is my private property”;
  
}

   public
string GetProperties()
  
{
      string properties = “MyPublicProperty = “ +
MyPublicProperty + “\r\n”;
     
properties += “MyPrivateProperty = “ + MyPrivateProperty;
      return properties;
  
}
#region ISerializable Members

   <summary>

   /// Special serialization constructor.

   </summary>

   <param name=”info”></param>

   <param name=”context”></param>

   public MyObject(SerializationInfo info,
StreamingContext context)
   {
     
_myPublicProperty = info.GetString(“MyPublicProperty”);
     
_myPrivateProperty = info.GetString(“MyPrivateProperty”);
   }
   <summary>

   /// Interface method to place the properties

   /// in the serialization queue

   ///
   </summary>

   ///
   <param name=”info”></param>

   <param name=”context”></param>

   public void GetObjectData(SerializationInfo info,
StreamingContext context)
   {
     
info.AddValue(“MyPublicProperty”, MyPublicProperty);
     
info.AddValue(“MyPrivateProperty”, MyPrivateProperty);
   }
#endregion
   }
}

The following code serializes and deserializes the object from and to a MemoryStream using our XmlFormatter. Please note that both the public and the private properties are being serialized.

using DotNetMagazine.September.Examples;
using System.IO;
using System.Xml;
using System.Data.SqlTypes;
namespace XmlFormatterSample
{
   class Program
  
{
      static void Main(string[] args)
     
{
        
MyObject object1 = new MyObject();
        
MyObject object2;
         // write the properties to the console
        
Console.WriteLine(“The properties of object1 are:”);
         
Console.WriteLine(object1.GetProperties());
        
Console.WriteLine();
         // serialize the object

         // ***************************************
        
MemoryStream stream = new MemoryStream();
        
XmlFormatter serializer = new XmlFormatter(typeof(MyObject));
        
serializer.Serialize(stream, object1);
         // reset the stream to the beginning
         
stream.Position = 0;
        
SqlXml xml = new SqlXml(stream);
         // ***************************************

         // write the XML value to the console
        
Console.WriteLine(“Xml value of object 1:”);
        
Console.WriteLine(xml.Value);
        
Console.WriteLine();
         // recreate the object in object 2

         using (MemoryStream stream2 =
new MemoryStream(Encoding.UTF8.GetBytes(xml.Value)))
        
{
           
object2 = (MyObject)serializer.Deserialize(stream2);
        
}

         // write the properties to the console
        
Console.WriteLine(“The properties of object2 are:”);
        
Console.WriteLine(object2.GetProperties());
        
Console.WriteLine();
        
Console.WriteLine(“Press any key to continue”);
         
Console.ReadKey();
      
}
  
}
}

The code is free to use in your projects. This code is also part of an article published in the Dutch version of the .NET (MSDN) magazine, September issue 2006: “Objecten en Sql Server 2005, XML als intermediair”.

This article was also published on the CodeProject in 2006, but copied to my blog for centralization.

I hope this formatter will be of use to you! You can find the source here and the demo version here.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

 
%d bloggers like this: