How C# Serialization Works: Step‑by‑Step Explained

Serialization is a fundamental concept in C# that allows you to convert objects into a format that can be easily stored or transmitted. Understanding serialization is crucial for building robust applications that involve data persistence, communication, and interoperability. This comprehensive guide will take you through the key aspects of C# serialization, including its types, best practices, and real-world applications.

What is Serialization in C#?

Serialization is the process of converting an object into a format that can be stored (e.g., a file or database) or transmitted (e.g., over a network). Deserialization is the reverse process—converting the stored data back into an object.

C# provides multiple serialization techniques, including:

Binary Serialization
XML Serialization
JSON Serialization
Custom Serialization

Each type of serialization has its use cases, advantages, and limitations. Let's explore them in detail.

1. Binary Serialization

Binary serialization is a mechanism that converts an object into a binary format. It is highly efficient but not human-readable.

How to Implement Binary Serialization

To serialize an object into a binary format, the class must be marked with the [Serializable] attribute, and the BinaryFormatter class is used (though now obsolete due to security concerns in .NET 5+).

[Serializable]
public class Employee
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// Serialize
var employee = new Employee { Name = "John Doe", Age = 30 };
using (FileStream fs = new FileStream("employee.dat", FileMode.Create))
{
    BinaryFormatter formatter = new BinaryFormatter();
    formatter.Serialize(fs, employee);
}

// Deserialize
using (FileStream fs = new FileStream("employee.dat", FileMode.Open))
{
    BinaryFormatter formatter = new BinaryFormatter();
    Employee deserializedEmployee = (Employee)formatter.Deserialize(fs);
    Console.WriteLine(deserializedEmployee.Name);
}

Security Concerns with Binary Serialization

BinaryFormatter is now considered insecure and is deprecated in .NET 5+. Microsoft recommends using safer alternatives like JSON or XML serialization.

2. XML Serialization

XML serialization converts objects into XML format, making it more readable and interoperable.

How to Implement XML Serialization

using System.Xml.Serialization;
using System.IO;

[XmlRoot("Employee")]
public class Employee
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// Serialize
var employee = new Employee { Name = "Jane Doe", Age = 28 };
XmlSerializer serializer = new XmlSerializer(typeof(Employee));
using (TextWriter writer = new StreamWriter("employee.xml"))
{
    serializer.Serialize(writer, employee);
}

// Deserialize
using (TextReader reader = new StreamReader("employee.xml"))
{
    Employee deserializedEmployee = (Employee)serializer.Deserialize(reader);
    Console.WriteLine(deserializedEmployee.Name);
}

Limitations of XML Serialization

Does not support private fields.
Slower compared to binary serialization.

3. JSON Serialization

JSON serialization is widely used in modern applications, particularly in web APIs and microservices.

How to Implement JSON Serialization Using System.Text.Json

using System.Text.Json;

public class Employee
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// Serialize
var employee = new Employee { Name = "Alice", Age = 35 };
string jsonString = JsonSerializer.Serialize(employee);
File.WriteAllText("employee.json", jsonString);

// Deserialize
string jsonFromFile = File.ReadAllText("employee.json");
Employee deserializedEmployee = JsonSerializer.Deserialize<Employee>(jsonFromFile);
Console.WriteLine(deserializedEmployee.Name);

Advantages of JSON Serialization

Fast and lightweight.
Human-readable and widely used in APIs.
Supported by System.Text.Json in .NET Core and .NET 5+.

4. Custom Serialization with ISerializable

For advanced use cases, you can implement the ISerializable interface to control how objects are serialized.

How to Implement Custom Serialization

using System.Runtime.Serialization;
using System.IO;

[Serializable]
public class Employee : ISerializable
{
    public string Name { get; set; }
    public int Age { get; set; }

    public Employee() { }
    
    protected Employee(SerializationInfo info, StreamingContext context)
    {
        Name = info.GetString("Name");
        Age = info.GetInt32("Age");
    }
    
    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("Name", Name);
        info.AddValue("Age", Age);
    }
}

When to Use Custom Serialization

When you need full control over how objects are serialized.
When dealing with complex object hierarchies.
When working with sensitive data that requires custom security measures.

Best Practices for Serialization in C#

Avoid BinaryFormatter in New Applications – Use System.Text.Json or XML serialization for safer alternatives.
Use Attributes Wisely – [Serializable] and [DataContract] should be used appropriately.
Consider Performance – JSON serialization is generally faster than XML serialization.
Secure Sensitive Data – Encrypt data before serialization if it contains sensitive information.
Optimize Large Objects – Avoid serializing large unnecessary objects; instead, serialize only essential data.

Conclusion

Serialization is an essential concept in C# that enables object persistence and data exchange. Whether you choose JSON, XML, or custom serialization depends on your specific use case. While JSON serialization is the most commonly used approach in modern applications, XML is still relevant for interoperability, and custom serialization offers advanced control.

By following best practices, you can implement efficient and secure serialization techniques in your C# applications.