Deep Serialization: Binary and SOAP Serialization with a Generic Twist

by Joe Finsterwald

This code sample applies to ASP.NET in the .NET 2.0 framework. Examples are written in C#.

The Problem
The Solution
Step 1: Binary Serialization to a Byte Array
Step 2: Binary Serialization to a File
Step 3: SOAP Serialization to a String
Step 4: Putting it all together
Conclusion

The Problem:

You have one of the following problems:

You need to persist an object to a storage medium.
You are using RPC.
You need to stream to a socket.

The solution:

Serialization allows you to convert a graph of objects into a linear sequence of bytes, XML, or SOAP. Once an object is flattened you can store it or send it over the wire. Serialized data can then be deserialized. Deserialization essentially reconstitutes the graph of objects you initially serialized. Serialization sounds complicated, but in practice it’s pretty easy because the .NET framework takes care of most of the complexity for you.

Microsoft's .NET framework provides two different options for persisting data or sending it over the network: shallow and deep serialization. Shallow serialization allows for the serialization of read-write property values of an object. Private data members and objects referenced by the object being serialized are ignored. Shallow serialization is used by Web Services and the XmlSerializer.

As you may have guessed from the title of this article the focus of this code sample is on deep serialization. Deep serialization serializes the whole object and any objects referenced by the object being serialized. This code sample demonstrates how to serialize data using the BinaryFormatter and the SoapFormatter. Both of these classes perform deep serialization.

In order to be eligible for serialization an object must be decorated with the [Serializable] attribute or implement the ISerializable interface. In the event that performance is an issue you can opt to exclude a field in an object from serialization by decorating the field with the [NonSerialized] attribute—this is called selective serialization.

I've written the following code samples to demonstrate how easy it is to implement serialization in your project.

Step 1: Binary Serialization to a Byte Array

Binary serialization uses the BinaryFormatter which is contained in the System.Runtime.Serialization.Formatters.Binary namespace. The BinaryFormatter classes implement the IRemotingFormatter interface to support remote procedure calls (RPCs), and the IFormatter interface (inherited by the IRemotingFormatter) to support serialization of a graph of objects.

Click to View the Code

BinarySerialization

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

namespace CoreWebLibrary.Utility
{
   public static class BinarySerialization
   {
      /// <summary>
      ///  Binary Serializes an object
      /// </summary>
      /// <param name="obj">The object to serialize</param>
      /// <returns>byte array</returns>
      public static byte[] BinarySerialize(Object obj)
      {
         byte[] serializedObject;
         MemoryStream ms = new MemoryStream();
         BinaryFormatter b = new BinaryFormatter();
         b.Serialize(ms, obj);
         ms.Seek(0, 0);
         serializedObject = ms.ToArray();
         ms.Close();

         return serializedObject;
      }

      /// <summary>
      ///  Binary DeSerializes an object
      /// </summary>
      /// <param name="obj">The object to serialize</param>
      /// <returns>The deserialized object</returns>
      public static T BinaryDeSerialize<T>(byte[] serializedObject)
      {
         MemoryStream ms = new MemoryStream();
         ms.Write(serializedObject, 0, serializedObject.Length);
         ms.Seek(0, 0);
         BinaryFormatter b = new BinaryFormatter();
         Object obj = b.Deserialize(ms);
         ms.Close();

         return (T)obj;
      }
   }
}

Step 2: Binary Serialization to a File

An example of binary serialization to a file.

Click to View the Code

FileSerialization

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

namespace CoreWebLibrary.Utility
{
   public static class FileSerialization
   {
      /// <summary>
      /// Serialize the object to a file
      /// </summary>
      /// <param name="obj">Object to be serialized.Ensure that 
      /// is Serializable !</param>
      /// <param name="filePath">File( with the entire file path) 
      //  where the object will be serialized to</param>
      public static void FileSerialize(Object obj, string filePath)
      {
         FileStream fileStream = null;

         try
         {
            fileStream = new FileStream(filePath, FileMode.Create);
            BinaryFormatter b = new BinaryFormatter();
            b.Serialize(fileStream, obj);
         }
         catch
         {
            throw;
         }
         finally
         {
            if (fileStream != null)
               fileStream.Close();
         }
      }

      /// <summary>
      /// Deserializes a binary formatted object.
      /// </summary>
      /// <param name="filePath">Full path of the file</param>
      /// <returns>The deserialized object</returns>
      public static T FileDeSerialize<T>(string filePath)
      {
         FileStream fileStream = null;
         Object obj;
         try
         {
            if (File.Exists(filePath) == false)
            {
               throw new FileNotFoundException("The file was not found.", 
                  filePath);
            }
            fileStream = new FileStream(filePath, FileMode.Open);
            BinaryFormatter b = new BinaryFormatter();
            obj = b.Deserialize(fileStream);
         }
         catch
         {
            throw;
         }
         finally
         {
            if (fileStream != null)
               fileStream.Close();
         }

         return (T)obj;
      }
   }
}

Step 3: SOAP Serialization to a String

SOAP serialization uses the SoapFormatter which is contained in the System.Runtime.Serialization.Formatters.Soap namespace. SOAP Serialization is more versatile than binary serialization, but versatility comes at a significant cost in terms of performance.

Click to View the Code

SoapSerialization

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Soap;
using System.Text;

namespace CoreWebLibrary.Utility
{
   public class SoapSerialization
   {
      /// <summary>
      /// Serializes the passed object using SOAP serialization
      /// </summary>
      /// <param name="obj">The object to serialize</param>
      /// <param name="encodingType">The encoding type to use</param>
      /// <returns>A string representing the serialized object.</returns>
      /// <remarks>encodingType is abstract: pass in a subtype of Encoding, for 
      /// example instantiate: System.Text.UTF8Encoding</remarks>
      public static string SoapMemoryStreamSerialization(object obj, 
        Encoding encodingType)
      {
         string xmlResult;

         using (Stream stream = new MemoryStream())
         {
            try
            {
               SoapFormatter sf = new SoapFormatter();
               sf.Serialize(stream, obj);
            }
            catch
            {
               throw;
            }

            stream.Position = 0;
            byte[] b = new byte[stream.Length];
            stream.Read(b, 0, (int)stream.Length);

            xmlResult = encodingType.GetString(b, 0, b.Length);
         }

         return xmlResult;
      }

      /// <summary>
      /// Deserailizes a SOAP serialized object
      /// </summary>
      /// <param name="input">The XML string to deserialize.</param>
      /// <param name="encodingType">The encoding type to use</param>
      /// <returns>The deserialized object.</returns>
      /// <remarks>encodingType is abstract: pass in a subtype of Encoding, for 
      /// example instantiate: System.Text.UTF8Encoding</remarks>
      public static T SoapDeserailization<T>(string input, 
         System.Text.Encoding encodingType)
      {
         Object obj = null;

         using (StringReader sr = new StringReader(input))
         {
            byte[] b;
            b = encodingType.GetBytes(input);

            Stream stream = new MemoryStream(b);

            try
            {
               SoapFormatter sf = new SoapFormatter();
               obj = (object)sf.Deserialize(stream);
            }
            catch
            {
               throw;
            }
         }

         return (T)obj;
      }
   }
}

Step 4: Putting it all together

I've put it altogether in one place if you want to include this code in a class library.

Click to View the Code

Serialization

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Text;

namespace CoreWebLibrary.Utility
{
   public class Serialization
   {
      /// <summary>
      ///  Binary Serializes an object
      /// </summary>
      /// <param name="obj">The object to serialize</param>
      /// <returns>byte array</returns>
      public static byte[] BinarySerialize(Object obj)
      {
         byte[] serializedObject;
         MemoryStream ms = new MemoryStream();
         BinaryFormatter b = new BinaryFormatter();
         b.Serialize(ms, obj);
         ms.Seek(0, 0);
         serializedObject = ms.ToArray();
         ms.Close();

         return serializedObject;
      }

      /// <summary>
      ///  Binary DeSerializes an object
      /// </summary>
      /// <param name="obj">The object to serialize</param>
      /// <returns>The deserialized object</returns>
      public static T BinaryDeSerialize<T>(byte[] serializedObject)
      {
         MemoryStream ms = new MemoryStream();
         ms.Write(serializedObject, 0, serializedObject.Length);
         ms.Seek(0, 0);
         BinaryFormatter b = new BinaryFormatter();
         Object obj = b.Deserialize(ms);
         ms.Close();

         return (T)obj;
      }

      /// <summary>
      /// Serialize the object to a file
      /// </summary>
      /// <param name="obj">Object to be serialized.Ensure that 
      /// is Serializable !</param>
      /// <param name="filePath">File( with the entire file path) 
      // where the object will be serialized to</param>
      public static void FileSerialize(Object obj, string filePath)
      {
         FileStream fileStream = null;

         try
         {
            fileStream = new FileStream(filePath, FileMode.Create);
            BinaryFormatter b = new BinaryFormatter();
            b.Serialize(fileStream, obj);
         }
         catch
         {
            throw;
         }
         finally
         {
            if (fileStream != null)
               fileStream.Close();
         }
      }

      /// <summary>
      /// Deserializes a binary formatted object.
      /// </summary>
      /// <param name="filePath">Full path of the file</param>
      /// <returns>The deserialized object</returns>
      public static T FileDeSerialize<T>(string filePath)
      {
         FileStream fileStream = null;
         Object obj;
         try
         {
            if (File.Exists(filePath) == false)
            {
               throw new FileNotFoundException("The file was not found.", 
                  filePath);
            }
            fileStream = new FileStream(filePath, FileMode.Open);
            BinaryFormatter b = new BinaryFormatter();
            obj = b.Deserialize(fileStream);
         }
         catch
         {
            throw;
         }
         finally
         {
            if (fileStream != null)
               fileStream.Close();
         }

         return (T)obj;
      }

      /// <summary>
      /// Serializes the passed object using SOAP serialization
      /// </summary>
      /// <param name="obj">The object to serialize</param>
      /// <param name="encodingType">The encoding type to use</param>
      /// <returns>A string representing the serialized object.</returns>
      /// <remarks>encodingType is abstract: pass in a 
      /// subtype of Encoding, for example instantiate: 
      /// System.Text.UTF8Encoding</remarks>
      public static string SoapMemoryStreamSerialization(object obj, 
        Encoding encodingType)
      {
         string xmlResult;

         using (Stream stream = new MemoryStream())
         {
            try
            {
               SoapFormatter sf = new SoapFormatter();
               sf.Serialize(stream, obj);
            }
            catch
            {
               throw;
            }

            stream.Position = 0;
            byte[] b = new byte[stream.Length];
            stream.Read(b, 0, (int)stream.Length);

            xmlResult = encodingType.GetString(b, 0, b.Length);
         }

         return xmlResult;
      }

      /// <summary>
      /// Deserailizes a SOAP serialized object
      /// </summary>
      /// <param name="input">The XML string to deserialize.</param>
      /// <param name="encodingType">The encoding type to use</param>
      /// <returns>The deserialized object.</returns>
      /// <remarks>encodingType is abstract: pass in a 
      /// subtype of Encoding, for 
      /// example instantiate: System.Text.UTF8Encoding</remarks>
      public static T SoapDeserailization<T>(string input, 
         System.Text.Encoding encodingType)
      {
         Object obj = null;

         using (StringReader sr = new StringReader(input))
         {
            byte[] b;
            b = encodingType.GetBytes(input);

            Stream stream = new MemoryStream(b);

            try
            {
               SoapFormatter sf = new SoapFormatter();
               obj = (object)sf.Deserialize(stream);
            }
            catch
            {
               throw;
            }
         }

         return (T)obj;
      }
   }
}

Conclusion:

Having an understanding of how serialization works is critically important if you want to be effective as a developer. Hopefully this example has demonstrated that deep serialization is both easy to implement and powerful.

Subject	Name	Date Submitted
Yes knowing serialization uis very important Yes the conclusion is very tru that knowing about serialization is very important for a developer Vikram http://www.vikramlakhotia.com/ Reply View Thread	Vikram	9/14/2006 1:07:27 AM
Serialization It is very helpful article. Briefly and clear. Thank you. Reply View Thread	Igor	9/14/2006 2:11:35 AM
re: Serialization Thanks! I'm glad you found it useful. Reply View Thread	Joe	9/18/2006 2:55:55 PM
Very useful article Your article is very usefull. Thanks. Reply View Thread	Sebastian	9/14/2006 10:30:08 AM
Useful Very Useful article for developers. Reply View Thread	Ashok Kumar	9/16/2006 8:30:03 AM
What is the T in T SoapDeserialization I understand that the 1st T is the return object type (don't see where it is declared in this example though) and I suspect that the 2nd serves for some sort of data conversion purpose but I would like to know for sure. Could anybody either give more details on the declaration and usage of the T in the following line: T SoapDeserailization , or just point me to an article where I could read more about it? Thanks, Aleksey Reply View Thread	Aleksey	9/25/2006 1:49:34 PM
re: What is the T in T SoapDeserialization Hi Aleksey, T is a type parameter. When you stipulate the 'type' of the type parameter the type you have chosen is substituted everywhere that the type parameters appears. Here's an example: string soapSerializedString = string.Empty; Authors a = new Authors(); Authors b; soapSerializedString = SoapMemoryStreamSerialization(a, System.Text.Encoding.UTF8); b = SoapDeserailization<Authors>(soapSerializedString, System.Text.Encoding.UTF8); Easy... and clean! Here is the link to the MSDN2 documentation on the topic: http://msdn2.microsoft.com/en-us/library/ms172193.aspx Reply View Thread	Joe	9/25/2006 5:32:45 PM
re: What is the T in T SoapDeserialization Thank you for the explanation and the link, Joe. Easy and clean! :) Reply View Thread	Aleksey	9/26/2006 9:37:56 AM
sr in SoapDeserailization method Maybe I'm getting blind, but I see an sr variable being declared and a new instance of the StringReader assigned to it, but I can't find a place where the sr variable is used. Reply View Thread	Aleksey	9/26/2006 9:50:04 AM
re: sr in SoapDeserailization method Good catch... My apologies if this created any confusion. I'll update my sample tonight! Reply View Thread	Joe	9/26/2006 1:47:29 PM


* Name:		Email Address:
Include me on future newsletters or mailings. (Your email address will not be displayed or shared.)
* Subject:
* Message:
Please enter the code shown below. If you cannot read it, press "reset image" to generate a new one.
		* Enter code:

Deep Serialization: Binary and SOAP Serialization with a Generic Twist

by Joe Finsterwald

Contents

The Problem:

The solution:

Step 1: Binary Serialization to a Byte Array

Step 2: Binary Serialization to a File

Step 3: SOAP Serialization to a String

Step 4: Putting it all together

Conclusion:

Comments

About the Author

Joseph Finsterwald

Other Articles by Joseph Finsterwald: