Binary Serialization with C# and .NET

Posted on Updated on


In the previous post, we discussed XML serialization. In this short article we are going to take a look at binary serialization via the BinaryFormatter class. As we mentioned in a previous article, binary serialization in .NET converts an object or entire object graph into a binary format that is not human readable. Binary serialization is sometimes called “deep” serialization because it serializes the entire object state, all relations among an object graph, and all references to other objects. It preserves type fidelity which is quite useful when utilizing objects across multiple applications of instances of the same application.

Binary Serialization with the BinaryFormatter class

To get started, let’s create a simple class, add some attributes to help us control how properties are serialized, then we’ll serialize and deserialize the object.

To get started, let’s create a C# Console Application that we will call BinarySerializationSample.

Create Binary Serialization Sample Application
Create Binary Serialization Sample Application

Next, we will add a class to the project. We will call this class Sample.

Let’s now add two properties – Name and Value as shown below then decorate the class with the Serializable attribute.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SerializationSample
{
    [Serializable]
    public class Sample
    {
        public string Name
        {
            get;
            set;
        }

        public Int32 Value
        {
            get;
            set;
        }
    }
}

Before we can use binary serialization, we have to add a reference to the System.Runtime.Serialization assembly. Right-click the project, select Add Reference, then select this assembly in the dialog. See below.

System.Runtime.Serialization Assembly Reference
System.Runtime.Serialization Assembly Reference

Now that we have created our Sample class, decorated it with the Serializable attribute, and added a reference to the System.Runtime.Serialization assembly, let’s jump to our Program class’s Main() method and write some simple code to serialize an instance of our object. The full code for our Program class is shown below.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;

namespace BinarySerializationSample
{
    class Program
    {
        static void Main(string[] args)
        {
            //create an instance of our Sample object
            Sample sample = new Sample();
            sample.Name = "John Nelson";
            sample.Value = 44;

            //create a FileStream to write the serialized output
            //to a file on our hard drive
            FileStream fileStream = new FileStream(@"c:\Temp\Sample.dat", FileMode.Create);

            //create a BinaryFormatter object to serialize our object
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(fileStream, sample);

        }
    }
}

Now let’s press F5 and run our console application. We will open the file with Wordpad so that the text wraps and so that we can see the contents. See below.

Output of Binary Serialization
Output of Binary Serialization

The binary output does have some readable text. The first thing you should notice is that the entire assembly and namespace information is stored with the serialized object. This is something that XML serialization does NOT do. Pretty cool.

Be sure not to save the file because we are going to use this same file in the code below to deserialize our object.

//create a FileStream to read the serialized object
FileStream fileStream = new FileStream(@"c:\Temp\Sample.dat", FileMode.Open);

//create a BinaryFormatter and deserialize the object
BinaryFormatter formatter = new BinaryFormatter();
Sample deserializedSample = (Sample)formatter.Deserialize(fileStream);

Console.WriteLine("The deserialized object:");
Console.WriteLine(String.Format("Name: {0}", deserializedSample.Name));
Console.WriteLine(String.Format("Value: {0}", deserializedSample.Value.ToString()));

Console.Read();

When we press F5 and run our application, we see the following output in our console window:

Binary Deserialization Output
Binary Deserialization Output

Pretty cool, right? Yes it is.

Now this was a very simple example but understand that any object that supports serialization can be serialized using the BinaryFormatter. If we have an object graph that contained multiple levels of objects in a hierarchy, we could serialize these objects in exactly the same way that we just did. I have written numerous applications that have required objects to be serialized and stored in a database. Again, we use the same approach, then we execute a stored procedure or invoke an insert or update call and pass the binary data into the table. No big deal.

In the next post, we will take a look at SOAP Serialization with C# and .NET.

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