M@rkJakes.com

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

		
[Serializable]
class Book
{
    public string Title;
    public string Author;
}

		Book b = new Book();
b.Title = "Learning C#";
b.Author = "Jon";

FileStream fs = new FileStream("books.dat", FileMode.CreateNew);
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(fs, b);
fs.Close();

Explanation

First we start by creating an instance of the Book class and give it’s members some values

Book b = new Book();
b.Title = "Learning C#";
b.Author = "Jon";

We then create a FileStream to a file that we want to write to, notice that I use the FileMode.CreateNew which would throw an exception if the file already exists. To read more about FileStreams check out Writing text to files.

FileStream fs = new FileStream("books.dat", FileMode.CreateNew);

We then create an instance of the BinaryFormatter class which we then use to serialize the object (the book) to the FileStream (into the file called books.dat). Note that the Serialize method accepts two parameters, the stream to which it shall write and the object to serialize. The stream could be any type of stream, so we could use the same method (different type of stream though) to send data over the Internet !

BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(fs, b);

We then make sure to close the stream.

fs.Close();

The data that gets stored in the binary file is the instance of the Book class I just created. The binary file also stores information about which version of which program actually wrote the file, so that we can make sure that we can read the file correctly again.

This can cause problems if we want another program to be able to read the binary file (deserialize the data), but that can be easily fixed by putting the class (or classes) that were serialized in a class library (dll file).

If I had wanted to store many books in this binary file the easiest way would have been to use a generic list to create a list of books which I then could serialize.

Book b1 = new Book();
b1.Title = "Learning C#";
b1.Author = "Jon";

Book b2 = new Book();
b2.Title = "Learning WPF";
b2.Author = "Jon";

List books = new List();
books.Add(b1);
books.Add(b2);

FileStream fs = new FileStream("books.dat", FileMode.CreateNew);
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(fs, books);
fs.Close();

But what if the class changes between versions of the program ? Can we still read the old data ? Well .NET has something called Version Tolerant Serialization, which makes it possible.

What about deserialization ?

To read the data (the instance of the book class) from the file we use the Deserialize method of the BinaryFormatter class. The Deserialize method takes one parameter, the stream the object is supposed to be read from.

	FileStream fs = new FileStream("books.dat", FileMode.Open);
BinaryFormatter bf = new BinaryFormatter();
Book b = (Book)bf.Deserialize(fs);
fs.Close();
Console.WriteLine(b.Title + " by " + b.Author);

The Deserialize method returns an object, which means we need to Type-Cast it to the right kind of a class (or an instance to be precise). This is done by putting the name of the class in front of the method surrounded by parenthesis.

	Book b = (Book)bf.Deserialize(fs);

If we were reading (loading) a list of books from the file that line would have been changed to this:

	List books = (List)bf.Deserialize(fs);

		[Serializable]
class Book : ISerializable
{
    private string _Title;
    private string _Author;

    public Book(string Title, string Author)
    {
        this._Title = Title;
        this._Author = Author;
    }

    public string Author
    {
        get { return _Author; }
        set { _Author = value; }
    }

    public string Title
    {
        get { return _Title; }
        set { _Title = value; }
    }

    public Book(SerializationInfo info, StreamingContext ctxt)
    {
        _Author = (string)info.GetValue("Author", typeof(string));
        _Title = (string)info.GetValue("Title", typeof(string));
    }

    public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
    {
        info.AddValue("Author", _Author);
        info.AddValue("Title", _Title);
    }
 }

		class Book : ISerializable

		public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
{
    info.AddValue("Author", _Author);
    info.AddValue("Title", _Title);
}

		public Book(SerializationInfo info, StreamingContext ctxt)
{
    _Author = (string)info.GetValue("Author", typeof(string));
    _Title = (string)info.GetValue("Title", typeof(string));
}