Serialization and DeSerialization in C#

Sanjay Kumar

13 Comments

Join the conversation! Your thoughts help the community grow.

Mariusz Postol2y ago
More about serialization you could learn by checking out "Information Computation Mastery: Serialization" available in the public domain at <https://www.c-sharpcorner.com/article/information-computation-mastery-serialization/>. I f you have any questions just ask.
- Sanjay Kumar2y ago
  Thanks for your suggestion
Mariusz Postol2y ago
In my opinion, this one could also be useful "External Streaming Data - Bitstream Format" at <https://www.c-sharpcorner.com/article/external-streaming-data-bitstream-format/>
- Sanjay Kumar2y ago
  Thanks for your suggestion
Mariusz Postol2y ago
I recommend my article <https://www.c-sharpcorner.com/article/external-data-file-and-stream-concepts/> titled "External Data - File and Stream Concepts".
Mariusz Postol2y ago
You said "Serialization is the process of converting an object into a format that can be easily stored or transmitted," How to distinguish a format "that can be easily..."? How to distinguish easy and difficult format?
- Mariusz Postol2y ago
  My point is that when talking about terms like simplicity, simplification, easy, hard, and difficult we need an engineering (we are engineers) measure to allow us to compare and find a result of a condition evaluation. It is much easier to express and justify your proposal stating that something is impossible. For example, because the binary format doesn't have standard encoding, and as a result standard syntax and semantics it is impossible to validate the bitstream correctness. In contrast, in this approach, we must be familiar with terms like encoding, syntax, and semantics and be able to distinguish definitions of the encoding and coding terms. Concluding, the main difference between binary and text-based formats is that there is no international standard for coding the result bitstream. Agree?
- Sanjay Kumar2y ago
  I would like to express my gratitude for the point you raised. I wish to clarify it based on my understanding. To differentiate between "easy" and "difficult" formats for serialization, one can consider the simplicity of processing, storing, and transmitting data. Formats such as JSON and XML are more accessible for human comprehension, debugging, and interpretation due to their structured text format. Conversely, a "difficult" format may be proprietary or tailored to specific systems, rendering it challenging to interpret without specialized knowledge or tools. The term "difficult" implies a lack of widespread support, which complicates data exchange between systems. I have employed these terms to indicate that the solution to any issue may depend on the user's level of understanding. A system that is easily comprehensible to any developer can be classified as simple and easy, while a system that poses challenges for the user can be deemed difficult; I do not intend to present this as a universal principle.
Mariusz Postol2y ago
As far as I know, XML is also a binary representation (it has associated coding), so what is the difference between binary format and XML?
- Mariusz Postol2y ago
  What do you mean by "a text-based format "? What is binary data in the sentence "binary formats rely on directly encoded binary data"? I am asking because any computer now is a binary machine, so the data must be binary!!
- Mariusz Postol2y ago
  "represented in binary form (0s and 1s)" - unfortunately it is not true. Look at any zooming CD or check out the discussion titled Binary coding system. <https://www.c-sharpcorner.com/forums/binary-coding-system> There is the sentence "The data on a CD is stored as microscopic pits (depressions) and lands (flat areas) on the reflective layer.". Fortunately, there is no doubt that it is a binary representation but there are no "0s and 1s" for sure.
- Sanjay Kumar2y ago
  You are entirely correct in stating that computers operate fundamentally as binary machines, with all data ultimately represented in binary form (0s and 1s). Nevertheless, when we discuss 'text-based formats' in contrast to 'binary formats,' we are addressing the methods by which data is represented and stored within files or transmitted across a network. When we talk about Text-based formats, such as JSON and XML, present data in a manner that is easily readable by humans. Although the underlying data is stored in a binary format, the essential aspect is that the information can be readily comprehended or modified by individuals in plain text. also Binary formats, conversely, preserve data in a compact and machine-optimized manner that is not easily readable by humans. These formats encode information directly in binary, resulting in greater efficiency regarding both storage capacity and processing speed. However, they necessitate the use of specialized software or libraries for reading and interpretation, as seen in formats such as PNG for images.

Serialization is the process of converting an object into a format that can be easily stored or transmitted, such as XML, JSON, SOAP, or binary format. Deserialization is the reverse process, converting the serialized data back into an object.

Types of Serialization Process

XML Serialization
JSON Serialization
Binary Serialization
SOAP Serialization

1. XML Serialization

XML serialization in .NET involves the process of transforming an object into an XML format, which facilitates easy storage, transfer, or sharing across different systems. In contrast to binary or SOAP serialization, XML serialization primarily focuses on the public fields and properties of an object, thereby providing a more straightforward and transparent method for data representation.

Features

Transform an object into XML format.
The predominant form of serialization is utilized for interoperability.
Public properties and fields undergo serialization, while private ones remain excluded.
Frequently employed in web services, configuration files, and for storage that is easily readable by humans.

Step 1. Create a class for XML serialization like the one below.

EmployeeDetails.cs

public class EmployeeDetails
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Address { get; set; }
    public string Hobbies { get; set; }
    public string EmployeeType { get; set; }
}

Step 2. Serialize the class EmployeeDetails.cs and save it according to the specified path.

public partial class MainWindow : Window
{
    EmployeeDetails employee;

    // Specify the file path where the XML file will be saved
    string filePath = @"C:\Users\sanjay\Desktop\Sanjay\SerailizedPath\"; // Change this to your desired location
    public MainWindow()
    {
        InitializeComponent();
        employee = new EmployeeDetails 
        { 
            Name = "Sanjay Kumar", 
            Age = 30, 
            Address = "Delhi", 
            EmployeeType = "Permanent", 
            Hobbies = "Cricket" 
        };
    }
    private void XmlSerialization_Click(object sender, RoutedEventArgs e)
    {
        // Create the XmlSerializer for the EmployeeDetails type
        XmlSerializer serializer = new XmlSerializer(typeof(EmployeeDetails));
        // Serialize the object to the specified location
        using (StreamWriter writer = new StreamWriter(Path.Combine(filePath, "Employee.xml")))
        {
            serializer.Serialize(writer, employee);
        }
    }
}

Step 3. DeSerialize the class EmployeeDetails.cs like below.

private void XmlDESerialization_Click(object sender, RoutedEventArgs e)
{
    XmlSerializer serializer = new XmlSerializer(typeof(EmployeeDetails));
    using (StreamReader reader = new StreamReader(Path.Combine(filePath, "Employee.xml")))
    {
        EmployeeDetails employeeDetails = (EmployeeDetails)serializer.Deserialize(reader);
        MessageBox.Show($"Name: {employeeDetails.Name}, Age: {employeeDetails.Age}, Address: {employeeDetails.Address}, EmployeeType: {employeeDetails.EmployeeType}, Hobbies: {employeeDetails.Hobbies}");
    }
}

2. JSON Serialization

In C#, JSON serialization is the process of transforming an object into a JSON string, while deserialization involves converting a JSON string back into an object. The System.Text.Json or Newtonsoft.Json libraries can be utilized for these operations.

Features

Transform an object into JSON format.
It is commonly utilized for web APIs, configuration files, and efficient data storage.
JSON serialization is supported by both the System.Text.Json and Newtonsoft.Json libraries.

Step 1. Create a class for JSON serialization like the one below.

EmployeeDetails.cs

public class EmployeeDetails
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Address { get; set; }
    public string Hobbies { get; set; }
    public string EmployeeType { get; set; }
}

Step 2. Serialize the EmployeeDetails.cs class into JSON format and save it to the specified location based on your requirements.

public partial class MainWindow : Window
{
    EmployeeDetails employee;

    // Specify the file path where the json file will be saved
    string filePath = @"C:\Users\sanjay\Desktop\Sanjay\SerailizedPath\"; // Change this to your desired location

    public MainWindow()
    {
        InitializeComponent();
        employee = new EmployeeDetails 
        { 
            Name = "Sanjay Kumar", 
            Age = 30, 
            Address = "Delhi", 
            EmployeeType = "Permanent", 
            Hobbies = "Cricket" 
        };
    }

    private void JsonSerialization_Click(object sender, RoutedEventArgs e)
    {
        string jsonString = JsonConvert.SerializeObject(employee, Formatting.Indented);
        File.WriteAllText(Path.Combine(filePath, "Employee.json"), jsonString);
        Debug.WriteLine("Object serialized to employee.json");
    }

    private void JsonDESerialization_Click(object sender, RoutedEventArgs e)
    {
        string jsonString = File.ReadAllText(Path.Combine(filePath, "Employee.json"));
        EmployeeDetails employee = JsonConvert.DeserializeObject<EmployeeDetails>(jsonString);
        MessageBox.Show($"Name: {employee.Name}, Age: {employee.Age}, Address: {employee.Address}, EmployeeType: {employee.EmployeeType}, Hobbies: {employee.Hobbies}");
    }
}

3. Binary Serialization

Binary serialization refers to the method of transforming an object into a binary format, enabling it to be saved in a file, transmitted across a network, or exchanged between applications. After the object has been serialized into binary, it can subsequently be deserialized, restoring it to its original state.

Features

Transform an object into a binary representation.
Optimized for size, though not easily interpretable by humans.
It necessitates that the object is annotated with the [Serializable] attribute.
Frequently employed for saving objects to storage or for communication between applications.

Step 1. Create a class for Binary serialization like the one below.

EmployeeDetails.cs

[Serializable]
public class EmployeeDetails
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Address { get; set; }
    public string Hobbies { get; set; }
    public string EmployeeType { get; set; }
}

Step 2. Serialize the EmployeeDetails.cs class in binary format and save it to the specified location based on your requirements.

public partial class MainWindow : Window
{
    EmployeeDetails employee;

    // Specify the file path where the Binary file will be saved
    string filePath = @"C:\Users\sanjay\Desktop\Sanjay\SerailizedPath\";  // Change this to your desired location

    public MainWindow()
    {
        InitializeComponent();
        employee = new EmployeeDetails 
        { 
            Name = "Sanjay Kumar", 
            Age = 30, 
            Address = "Delhi", 
            EmployeeType = "Permanent", 
            Hobbies = "Cricket" 
        };
    }

    [Obsolete]
    private void BinarySerialization_Click(object sender, RoutedEventArgs e)
    {
        BinaryFormatter formatter = new BinaryFormatter();

        using (FileStream stream = new FileStream(Path.Combine(filePath, "Employee.dat"), FileMode.Create))
        {
            formatter.Serialize(stream, employee);
        }

        Debug.WriteLine("Object serialized to employee.dat");
    }
}

Step 3. DeSerialize the class EmployeeDetails.cs like below.

[Obsolete]
private void BinaryDESerialization_Click(object sender, RoutedEventArgs e)
{
    BinaryFormatter formatter = new BinaryFormatter();
    using (FileStream stream = new FileStream(Path.Combine(filePath, "employee.dat"), FileMode.Open))
    {
        EmployeeDetails person = (EmployeeDetails)formatter.Deserialize(stream);
        MessageBox.Show($"Name: {person.Name}, Age: {person.Age}, Address: {person.Address}, EmployeeType: {person.EmployeeType}, Hobbies: {person.Hobbies}");
    }
}

4. SOAP Serialization

It refers to the method of transforming an object into the XML format defined by the Simple Object Access Protocol (SOAP), facilitating its transmission across a network, particularly within web services. While SOAP was widely utilized in earlier web service architectures, its prevalence has diminished in recent years, largely due to the increasing adoption of RESTful APIs and JSON serialization.

Features

Utilizes the SOAP (Simple Object Access Protocol) format.
Traditionally employed in web services.

Step 1. Add the “SoapFormatter” Nuget package as shown below.

SoapFormatter

Step 2. Create a class for soap serialization like the one below.

EmployeeDetails.cs

public class EmployeeDetails
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Address { get; set; }
    public string Hobbies { get; set; }
    public string EmployeeType { get; set; }
}

Step 3. Serialize the EmployeeDetails.cs class into Soap format and save it to the specified location based on your requirements.

public partial class MainWindow : Window
{
    EmployeeDetails employee;
    // Specify the file path where the Soap file will be saved
    string filePath = @"C:\Users\sanjay\Desktop\Sanjay\SerailizedPath\"; // Change this to your desired location
    public MainWindow()
    {
        InitializeComponent();
        employee = new EmployeeDetails 
        { 
            Name = "Sanjay Kumar", 
            Age = 30, 
            Address = "Delhi", 
            EmployeeType = "Permanent", 
            Hobbies = "Cricket" 
        };
    }
    private void SoapSerialization_Click(object sender, RoutedEventArgs e)
    {
        SoapFormatter formatter = new SoapFormatter();
        using (FileStream stream = new FileStream(Path.Combine(filePath, "Employee.soap"), FileMode.Create))
        {
            formatter.Serialize(stream, employee);
        }
        Debug.WriteLine("Object serialized to employee.soap");
    }
}

Step 4. DeSerialize the class EmployeeDetails.cs like below.

private void SoapDESerialization_Click(object sender, RoutedEventArgs e)
{
    SoapFormatter formatter = new SoapFormatter();
    using (FileStream stream = new FileStream(Path.Combine(filePath, "employee.soap"), FileMode.Open))
    {
        EmployeeDetails person = (EmployeeDetails)formatter.Deserialize(stream);
        MessageBox.Show($"Name: {person.Name}, Age: {person.Age}, Address: {person.Address}, EmployeeType: {person.EmployeeType}, Hobbies: {person.Hobbies}");
    }
}

Note. The results of all the aforementioned formats can be observed by executing the application as demonstrated below. Various serialization methods cater to distinct use cases influenced by requirements for performance, interoperability, and readability.

Serialization methods