Strategy for deserializing a class that has changed in .NET

Question

I have this class

[Serializable]
public class myClass() : ISerializable
{
    public int a;
    public int b;
    public int c;

    public void GetObjectData(SerializationInfo info, 
                              StreamingContext context)
        {
        // Some code
        }

    public myClass(SerializationInfo info, 
                   StreamingContext context)
        {
        // Some code
        }
}

I have hundreds of these object in my database. I am now ready to publish a new version of my app where the class has morphed to

[Serializable]
public class myClass() : ISerializable
{
    public int a;
    public string b;
    public int c;
    public bool d;

    public void GetObjectData(SerializationInfo info, 
                              StreamingContext context)
        {
        // Some code
        }

    public myClass(SerializationInfo info, 
                   StreamingContext context)
        {
        // Some code
        }
}

How would one deserialize an object serialized based on the first version with the de-serialization constructor of the second.

Are there also strategies for future version proofing my second version of the class?

Answer 1

Without preparation on your part, you may need to resort to a hack: when your public myClass deserialization constructor gets the value of bool d, enclose the code in try/catch, and set d to its default value when you catch an exception.

In the future, add an int value "__ver" (or any other name that does not collide with arguments that you pass to info.AddValue), and set it to a constant that you maintain in your class to indicate compatible and incompatible changes in serialization:

public class myClass : ISerializable {
    private const int __ver = 4;
    public int a;
    public string b;
    public int c;
    public bool d;

    public void GetObjectData(SerializationInfo info, 
                          StreamingContext context) {
        info.AddValue("__ver", ver);
        info.AddValue("a", a);
        // and so on
    }

    public myClass(SerializationInfo info, 
               StreamingContext context) {
        switch(info.GetInt32("__ver")) {
            case 3: 
                // Deserialize prior version
            break;
            case 4: 
                // Deserialize current version
            break;
        }
    }
}

Answer 2

Serializable classes are great for passing them around through the same version of software, but you hit this issue quickly when using it for persistence. If you are going to store objects as BLOBs, then maybe use something like protobuf-net which allows serialization versioning by allowing for optional fields.

Given your current predicament all you can do to get it to work imediatly is put a try catch around the new fields, and then default them if they are not there:

protected myClass(SerializationInfo info, StreamingContext context)
{
    c = info.GetInt32("Value_C"); 
    try
    {
        b = info.GetBoolean("Value_B");
    }
    catch (SerializationException)
    {
        b = true;
    }
}