Question

I’m using DataContracts to serialize objects. Suppose I have serialized a data structured in this way:

[DataContract]
public class Dog : IExtensibleDataObject
{
    [DataMember]
    public int age;

    [DataMember]
    public string name;

    ExtensionDataObject IExtensibleDataObject.ExtensionData { get; set; }
}

Now I’m changing my architecture and I would like to read the previously serialized data with this classes:

[DataContract]
[KnownType(typeof(Dog))]
public class Animal : IExtensibleDataObject
{
    [DataMember]
    public string name;

    ExtensionDataObject IExtensibleDataObject.ExtensionData { get; set; }
}

[DataContract]
public class Dog : Animal
{
    [DataMember]
    public int age;
}

but I obtain name = null. I know that this depends on the order: the file was saved with age for first and then read starting from name, because it is on the base class.
Is there a way to handle this, maybe by changing the order?

Answer 1

I don’t think that’s possible.

The xml in the past would have been

<dog>
    <name>Bob</name>
    <age>10</age>
</dog>

Its now expecting

<animal>
    <name>Bob</name>
    <dog>
        <age>10</age>
    </dog>
</animal>

The property is higher up in anything that’s serialized on the new DataContract.
Changing inheritance heirarchy is a breaking change with the IExtensibleDataObject method.

The use of inheritance together with data contracts is allowed,
provided that inheritance is not used as a versioning mechanism and
that certain rules are followed. If a type derives from a certain base
type, do not make it derive from a different base type in a future
version (unless it has the same data contract). There is one exception
to this: you can insert a type into the hierarchy between a data
contract type and its base type, but only if it does not contain data
members with the same names as other members in any possible versions
of the other types in the hierarchy. In general, using data members
with the same names at different levels of the same inheritance
hierarchy can lead to serious versioning problems and should be
avoided.

More at Best Practices: Data Contract Versioning

Edit 1:

You could perhaps try making Name virtual in Animal and overriding it in Dog? Or some crazy method to force the serialized new version to have name under dog. i.e. something like,

[DataContract] 
[KnownType(typeof(Dog))] 
public class Animal : IExtensibleDataObject 
{
    public virtual string name; 

    ExtensionDataObject IExtensibleDataObject.ExtensionData { get; set; } 
} 

[DataContract] 
public class Dog : Animal 
{ 
    [DataMember] 
    public override string name; 

    [DataMember] 
    public int age; 
}