Binary File Operations In C# Complete Guide

Introduction to Binary File Operations

Binary file operations involve reading from and writing to files as raw bytes. This is useful when dealing with non-text files (like images, audio/video files, or custom file formats). In C#, binary file operations can be performed using classes from the System.IO namespace.

Step-by-Step Guide

Step 1: Writing to a Binary File

In this step, we'll write some basic data (integers and strings) to a binary file.

Complete Example:

using System;
using System.IO;

class BinaryFileWriteExample
{
    static void Main()
    {
        // Define the file path
        string filePath = "example.bin";

        // Create a BinaryWriter instance to write to the file
        using (BinaryWriter writer = new BinaryWriter(File.Open(filePath, FileMode.Create)))
        {
            // Write data to the binary file
            writer.Write(1234);        // Write an integer
            writer.Write(3.1415926);  // Write a double
            writer.Write("Hello");    // Write a string
        }

        Console.WriteLine("Binary file has been created and data written.");
    }
}

Explanation:

• FileMode.Create: Opens a file if it exists; otherwise, a new file is created.
• using statement: Ensures that the BinaryWriter is disposed of properly, even if an exception occurs.
• Write method: Writes the specified primitive type or string to the current stream.

Step 2: Reading from a Binary File

Now, we'll read the data written in the previous step back from the binary file.

Complete Example:

using System;
using System.IO;

class BinaryFileReadExample
{
    static void Main()
    {
        // Define the file path
        string filePath = "example.bin";

        // Create a BinaryReader instance to read from the file
        using (BinaryReader reader = new BinaryReader(File.Open(filePath, FileMode.Open)))
        {
            // Read data from the binary file
            int intValue = reader.ReadInt32();    // Read an integer
            double doubleValue = reader.ReadDouble(); // Read a double
            string stringValue = reader.ReadString(); // Read a string

            // Display the data read from the binary file
            Console.WriteLine($"Integer: {intValue}");
            Console.WriteLine($"Double: {doubleValue}");
            Console.WriteLine($"String: {stringValue}");
        }
    }
}

Explanation:

• FileMode.Open: Opens an existing file. The error occurs if the specified file does not exist.
• ReadXXX methods: Reads the primitive data type or string from the current stream.

Step 3: Writing and Reading Custom Objects

Here, we'll demonstrate how to write and read a custom object to and from a binary file. This involves implementing the ISerializable interface or using binary serialization.

Complete Example:

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

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

    public override string ToString()
    {
        return $"Name: {Name}, Age: {Age}";
    }
}

class BinaryFileCustomObjectExample
{
    static void Main()
    {
        // Define the file path
        string filePath = "person.bin";

        // Create a Person object
        Person person = new Person { Name = "John Doe", Age = 30 };

        // Serialize the Person object to a binary file
        using (FileStream fileStream = new FileStream(filePath, FileMode.Create))
        {
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(fileStream, person);
        }

        Console.WriteLine("Person object has been serialized to a binary file.");

        // Deserialize the Person object from the binary file
        Person deserializedPerson;
        using (FileStream fileStream = new FileStream(filePath, FileMode.Open))
        {
            BinaryFormatter formatter = new BinaryFormatter();
            deserializedPerson = (Person)formatter.Deserialize(fileStream);
        }

        Console.WriteLine("Person object has been deserialized from the binary file.");
        Console.WriteLine(deserializedPerson);
    }
}

Explanation:

• [Serializable] attribute: Indicates that a class can be serialized.
• FileStream: A stream for a file.
• BinaryFormatter: Converts the object to and from a binary format.
• Serialize method: Writes the specified object to a binary stream.
• Deserialize method: Reconstructs an object from a binary stream.

Important Considerations:

• BinaryFormatter is not recommended for new applications due to security concerns. Consider using safer alternatives like System.Text.Json or Newtonsoft.Json for JSON serialization.
• Binary serialization is beneficial for performance but may lead to compatibility issues between different software versions.

Conclusion

Binary file operations in C# allow you to read and write raw bytes, making them ideal for non-text file handling. By using BinaryReader and BinaryWriter, you can perform basic read/write operations on primitive types and strings. For more complex data, custom objects can be serialized and deserialized using BinaryFormatter, though alternatives like JSON are generally preferred for new projects.