Question

I have a class, that should support version tolerant serialization

[Serializable]
class A {
    [OptionalField]
    int a;

    [OptionalField]
    MyClass b;

    [OptionalField]
    MyClass c;
}

• How can I correct missing fields after deserialization? I guess, I have to use method marked with [OnDeserializing]. But how can I get which of fields was ignored?
• Can I configure auto-deserialization to initialize field by default constructor in case of them missing?

Answer 1

Additionally, you can use OnSerializingAttribute and OnSerializedAttribute to set the fields. As the example shows, fields that have been already set will keep their value. Note, however, that this is only the case if the field is set during the OnSerializing event. Fields set during the OnSerialized event will override the serialized value.

EDIT: In this case you can check in your method (decorated with OnSerialized) if the field equals to null and instantiate when necessary. If there is the possibility that this field is never be used and its creation can be deferred, think about hiding the field in question behind a property and instantiate it lazily.

Models.cs:

using System;
using System.Runtime.Serialization;

namespace SerializationExample
{
    [Serializable]
    public class Model
    {
        public Model(){
            A = new SomeClass();
        }

        [OptionalField]
        public int value;

        [OptionalField]
        public SomeClass A;

        [OptionalField]
        public AnotherClass B;            

        [OnDeserializing]
        void OnDeserializing(StreamingContext context)
        {
            B = new AnotherClass("Set during deserializing");
        }

        [OnDeserialized]
        void OnDeserialized(StreamingContext context)
        {
            // Do sth. here after the object has been deserialized
        }

        public override string ToString()
        {
            return String.Format("A: {0}\nB: {1}", A, B);
        }

    }

    [Serializable]
    public class SomeClass
    {
        public string Value { get; set; }

        public SomeClass()
        {
            Value = "Default";
        }

        public override string ToString()
        {
            return Value;
        }
    }

    [Serializable]
    public class AnotherClass
    {
        public string Value { get; private set; }

        public AnotherClass(string v)
        {
            Value = v;
        }

        public override string ToString()
        {
            return Value;
        }
    }
}

Program.cs:

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

namespace SerializationExample
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] FileNames = new string[] {
                @"model1.bin",
                @"model2.bin"
            };

            Stream[] files = new Stream[] {
                File.Create(FileNames[0]),
                File.Create(FileNames[1])
            };

            BinaryFormatter bf = new BinaryFormatter();

            Model m1 = new Model();
            m1.B = new AnotherClass("Set in app");
            m1.A.Value = "Set in app";

            Model m2 = new Model();

            Console.WriteLine("M1:\n{0}\n", m1);
            Console.WriteLine("M2:\n{0}\n\n", m2);

            bf.Serialize(files[0], m1);
            bf.Serialize(files[1], m2);

            foreach (var f in files)
                f.Seek(0, SeekOrigin.Begin);

            m1 = null;
            m2 = null;

            m1 = (Model)bf.Deserialize(files[0]);
            m2 = (Model)bf.Deserialize(files[1]);

            Console.WriteLine("M1:\n{0}\n", m1);
            Console.WriteLine("M2:\n{0}\n\n", m2);

            foreach (var f in files)
                f.Close();           
        }
    }
}

Output:

M1:
A: Set in app
B: Set in app

M2:
A: Default
B:


M1:
A: Set in app
B: Set in app

M2:
A: Default
B: Set during deserializing