Contribute
Ask Question

Serializing Objects In C#

Serialization in C# is the process of converting an object into a stream of bytes to store the object to memory, a database, or a file. Its main purpose is to save the state of an object in order to be able to recreate it when needed. The reverse process is called deserialization.

Introduction

 
Often times, we need to store objects to a physical storage so it can be read back and converted back to an object. The process of storing an object to a physical storage is called serialization. The process of reading a serialized object back into memory id deserialization.
 
In simple words serialization is a process of storing the object instance to a disk file. Serialization stores state of the object i.e. member variable values to disk. Deserialization is reverse of serialization i.e. it's a process of reading objects from a file where they have been stored. In this code sample we will see how to serialize and deserialize objects using C#.
 
Here is how serialization works. Image source: Microsoft Docs.
 
Serialization in CSharp 

Namespaces involved


Following namespaces are involved in serialization process,
  • System.Runtime.Serialization
  • System.Runtime.Serialization.Formatters.Binary

Example 1

  1. using System;  
  2. using System.IO;  
  3. using System.Runtime.Serialization;  
  4. using System.Runtime.Serialization.Formatters.Binary;  
  5. public class SerialTest {  
  6.     public void SerializeNow() {  
  7.         ClassToSerialize c = new ClassToSerialize();  
  8.         File f = new File("temp.dat");  
  9.         Stream s = f.Open(FileMode.Create);  
  10.         BinaryFormatter b = new BinaryFormatter();  
  11.         b.Serialize(s, c);  
  12.         s.Close();  
  13.     }  
  14.     public void DeSerializeNow() {  
  15.         ClassToSerialize c = new ClassToSerialize();  
  16.         File f = new File("temp.dat");  
  17.         Stream s = f.Open(FileMode.Open);  
  18.         BinaryFormatter b = new BinaryFormatter();  
  19.         c = (ClassToSerialize) b.Deserialize(s);  
  20.         Console.WriteLine(c.name);  
  21.         s.Close();  
  22.     }  
  23.     public static void Main(string[] s) {  
  24.         SerialTest st = new SerialTest();  
  25.         st.SerializeNow();  
  26.         st.DeSerializeNow();  
  27.     }  
  28. }  
  29. public class ClassToSerialize {  
  30.     public int age = 100;  
  31.     public string name = "bipin";  
  32. }  

Explanation

Here we have our own class named ClassToSerialize. This class has two public valiables name and age with some default values. We will write this class to a disk file (temp.dat) using SerializeTest class.

SerializeTest class has two methods SerializeNow() and DeSerializeNow() which perform the task of serialization and deserialization respectively.

The general steps for serializing are,

  • Create an instance of File that will store serialized object.
  • Create a stream from the file object.
  • Create an instance of BinaryFormatter.
  • Call serialize method of the instance passing it stream and object to serialize.

The steps for de-serializing the object are similar. The only change is that you need to call deserialize method of BinaryFormatter object.

Now, let us see an example where we have used 'real' class with public and shared members and properties to encapsulate them. The class also uses another supporting class. This is just to make clear that if your class contains further classes, all the classes in the chain will be serialized.

Example 2

  1. using System;  
  2. using System.IO;  
  3. using System.Runtime.Serialization;  
  4. using System.Runtime.Serialization.Formatters.Binary;  
  5. public class SerialTest {  
  6.     public void SerializeNow() {  
  7.         ClassToSerialize c = new ClassToSerialize();  
  8.         c.Name = "bipin";  
  9.         c.Age = 26;  
  10.         ClassToSerialize.CompanyName = "xyz";  
  11.         File f = new File("temp.dat");  
  12.         Stream s = f.Open(FileMode.Create);  
  13.         BinaryFormatter b = new BinaryFormatter();  
  14.         b.Serialize(s, c);  
  15.         s.Close();  
  16.     }  
  17.     public void DeSerializeNow() {  
  18.         ClassToSerialize c = new ClassToSerialize();  
  19.         File f = new File("temp.dat");  
  20.         Stream s = f.Open(FileMode.Open);  
  21.         BinaryFormatter b = new BinaryFormatter();  
  22.         c = (ClassToSerialize) b.Deserialize(s);  
  23.         Console.WriteLine("Name :" + c.Name);  
  24.         Console.WriteLine("Age :" + c.Age);  
  25.         Console.WriteLine("Company Name :" + ClassToSerialize.CompanyName);  
  26.         Console.WriteLine("Company Name :" + c.GetSupportClassString());  
  27.         s.Close();  
  28.     }  
  29.     public static void Main(string[] s) {  
  30.         SerialTest st = new SerialTest();  
  31.         st.SerializeNow();  
  32.         st.DeSerializeNow();  
  33.     }  
  34. }  
  35. public class ClassToSerialize {  
  36.     private int age;  
  37.     private string name;  
  38.     static string companyname;  
  39.     SupportClass supp = new SupportClass();  
  40.     public ClassToSerialize() {  
  41.         supp.SupportClassString = "In support class";  
  42.     }  
  43.     public int Age {  
  44.         get {  
  45.             return age;  
  46.         }  
  47.         set {  
  48.             age = value;  
  49.         }  
  50.     }  
  51.     public string Name {  
  52.         get {  
  53.             return name;  
  54.         }  
  55.         set {  
  56.             name = value;  
  57.         }  
  58.     }  
  59.     public static string CompanyName {  
  60.         get {  
  61.             return companyname;  
  62.         }  
  63.         set {  
  64.             companyname = value;  
  65.         }  
  66.     }  
  67.     public string GetSupportClassString() {  
  68.         return supp.SupportClassString;  
  69.     }  
  70. }  
  71. public class SupportClass {  
  72.     public string SupportClassString;  
  73. }  

Example 3

The final example shows how to serialize array of objects.

  1. using System;  
  2. using System.IO;  
  3. using System.Runtime.Serialization;  
  4. using System.Runtime.Serialization.Formatters.Binary;  
  5. public class SerialTest {  
  6.     public void SerializeNow() {  
  7.         ClassToSerialize[] c = new ClassToSerialize[3];  
  8.         c[0] = new ClassToSerialize();  
  9.         c[0].Name = "bipin";  
  10.         c[0].Age = 26;  
  11.         c[1] = new ClassToSerialize();  
  12.         c[1].Name = "abc";  
  13.         c[1].Age = 75;  
  14.         c[2] = new ClassToSerialize();  
  15.         c[2].Name = "pqr";  
  16.         c[2].Age = 50;  
  17.         ClassToSerialize.CompanyName = "xyz";  
  18.         File f = new File("temp.dat");  
  19.         Stream s = f.Open(FileMode.Create);  
  20.         BinaryFormatter b = new BinaryFormatter();  
  21.         b.Serialize(s, c);  
  22.         s.Close();  
  23.     }  
  24.     public void DeSerializeNow() {  
  25.         ClassToSerialize[] c;  
  26.         File f = new File("temp.dat");  
  27.         Stream s = f.Open(FileMode.Open);  
  28.         BinaryFormatter b = new BinaryFormatter();  
  29.         c = (ClassToSerialize[]) b.Deserialize(s);  
  30.         Console.WriteLine("Name :" + c[2].Name);  
  31.         Console.WriteLine("Age :" + c[2].Age);  
  32.         Console.WriteLine("Company Name :" + ClassToSerialize.CompanyName);  
  33.         s.Close();  
  34.     }  
  35.     public static void Main(string[] s) {  
  36.         SerialTest st = new SerialTest();  
  37.         st.SerializeNow();  
  38.         st.DeSerializeNow();  
  39.     }  
  40. }  
  41. public class ClassToSerialize {  
  42.     private int age;  
  43.     private string name;  
  44.     static string companyname;  
  45.     public int Age {  
  46.         get {  
  47.             return age;  
  48.         }  
  49.         set {  
  50.             age = value;  
  51.         }  
  52.     }  
  53.     public string Name {  
  54.         get {  
  55.             return name;  
  56.         }  
  57.         set {  
  58.             name = value;  
  59.         }  
  60.     }  
  61.     public static string CompanyName {  
  62.         get {  
  63.             return companyname;  
  64.         }  
  65.         set {  
  66.             companyname = value;  
  67.         }  
  68.     }  
  69. }  

TRENDING UP

View All