How do you migrate from a list to a class C# DataContract Serialization?

Question

How can I migrate a configuration to a new class from a list of bools? Previously it used a list of bool, but the list was being abused as a class, with each index having a specific meaning like a field.

I want to migrate it from a List, to a class that instead acts as the list for serialization purposes, but exposes normal fields to the rest of the application.

How can I write class ListEmulator so that it serializes out to a list, without introducing new xml tags?

old code

namespace
{
    [DataContract]
    public class Configuration
    {
        public const string FileName = "Configuration.xml";

        public Configuration()
        {
            AList = new List<bool>();
            AGuidList = new List<Guid>();
        }

        [DataMember]
        public List<Guid> AGuidList { get; set; }
        [DataMember]
        public List<bool> AList { get; set; }
    }
}

new code.

namespace
{
    [DataContract]
    public class Configuration
    {
        public const string FileName = "Configuration.xml";

        public Configuration()
        {
            AListEmulator = new ListEmulator();
            AGuidList = new List<Guid>();
        }

        [DataMember]
        public List<Guid> AGuidList { get; set; }
        [DataMember]
        public ListEmulator AListEmulator { get; set; }
    }
}

public class ListEmulator
{

    public ListEmulator()
    {
        new ListEmulator(true, true, true, true);
    }

    public ListEmulator(bool item0, bool item1, bool item2, bool item3)
    {
        this.IsPlanned = item0;
        this.IsCompleted = item1;
        this.IsRemaining = item2;
        this.IsSerial = item3;
    }

    public bool IsPlanned { get; set; }
    public bool IsCompleted { get; set; }
    public bool IsRemaining { get; set; }
    public bool IsSerial { get; set; }
}

The reason a list is needed, is there is old migration code that needs to be ported for when there was only 1 element, then 2, 3, 4 with different defaults for each. If it weren't for the fact that I have existing deployed configuration files in the original format, it would probably be time for them to all be named in the XML individually. However, I need to retain the current format for now. For the sake of migration I'm wondering how I can accomplish the above.

Answer 1

One option would be for your ListEmulator to inherit from Collection<bool>, and then add specific named properties to access elements in the array, like so:

public class ListEmulator : Collection<bool>
{
    const bool IsPlannedDefault = false;  // Change to the appropriate values.
    const bool IsCompletedDefault = false;
    const bool IsRemainingDefault = false;
    const bool IsSerialDefault = false;

    void AddAllDefaults()
    {
        // Customize the code here to upgrade old collections with fewer than 4 elements to the current 4-element format.
        if (Count < 1)
            Add(IsPlannedDefault);
        if (Count < 2)
            Add(IsCompletedDefault);
        if (Count < 3)
            Add(IsRemainingDefault);
        if (Count < 4)
            Add(IsSerialDefault);
    }

    public ListEmulator() { }

    public ListEmulator(bool item0, bool item1, bool item2, bool item3)
    {
        this.IsPlanned = item0;
        this.IsCompleted = item1;
        this.IsRemaining = item2;
        this.IsSerial = item3;
    }

    public bool IsPlanned { get { return this.ElementAtOrDefault(0, IsPlannedDefault); } set { AddAllDefaults(); this[0] = value; } }
    public bool IsCompleted { get { return this.ElementAtOrDefault(1, IsCompletedDefault); } set { AddAllDefaults(); this[1] = value; } }
    public bool IsRemaining { get { return this.ElementAtOrDefault(2, IsRemainingDefault); } set { AddAllDefaults(); this[2] = value; } }
    public bool IsSerial { get { return this.ElementAtOrDefault(3, IsSerialDefault); } set { AddAllDefaults(); this[3] = value; } }

    protected override void InsertItem(int index, bool item)
    {
        if (index > 3)
            throw new ArgumentOutOfRangeException("index > 3");
        base.InsertItem(index, item);
    }
}

Then in your Configuration simply replace List<bool> with ListEmulator, keeping the old element name:

    [DataMember]
    public ListEmulator AList { get; set; }

Because this type implements IEnumerable<T>, the DataContractSerializer will serialize it as a collection rather than as an object with properties. (You might want to change the class name since it's really not a list emulator at this point.) However, this only works if you do not add any initial values to the collection from within the default constructor.

Another option would be to add a surrogate property to Configuration that handles the necessary conversions, and mark the ListEmulator AList as not serialized:

[DataContract]
public class Configuration
{
    public const string FileName = "Configuration.xml";

    public Configuration()
    {
        AList = new ListEmulator();
        AGuidList = new List<Guid>();
    }

    [DataMember]
    public List<Guid> AGuidList { get; set; }

    [DataMember(Name = "AList")]
    bool[] AlistArray
    {
        get
        {
            return AList == null ? null : AList.ToArray();
        }
        set
        {
            AList = new ListEmulator(value);
        }
    }

    [IgnoreDataMember] // Do not serialize this property directly
    public ListEmulator AList { get; set; }
}

public class ListEmulator
{
    const bool IsPlannedDefault = false;  // Change to the appropriate values.
    const bool IsCompletedDefault = false;
    const bool IsRemainingDefault = false;
    const bool IsSerialDefault = false;

    public ListEmulator(IList<bool> list)
    {
        IsPlanned = list.ElementAtOrDefault(0, IsPlannedDefault);
        IsCompleted = list.ElementAtOrDefault(1, IsCompletedDefault);
        IsRemaining = list.ElementAtOrDefault(2, IsRemainingDefault);
        IsSerial = list.ElementAtOrDefault(3, IsSerialDefault);
    }

    public ListEmulator()
    {
        new ListEmulator(true, true, true, true);
    }

    public ListEmulator(bool item0, bool item1, bool item2, bool item3)
    {
        this.IsPlanned = item0;
        this.IsCompleted = item1;
        this.IsRemaining = item2;
        this.IsSerial = item3;
    }

    public bool IsPlanned { get; set; }
    public bool IsCompleted { get; set; }
    public bool IsRemaining { get; set; }
    public bool IsSerial { get; set; }

    public bool[] ToArray()
    {
        return new[] { IsPlanned, IsCompleted, IsRemaining, IsSerial };
    }
}

Both options use the following extension method:

public static class ListExtensions
{
    public static T ElementAtOrDefault<T>(this IList<T> list, int index, T defaultValue)
    {
        if (index < 0)
            throw new ArgumentOutOfRangeException(string.Format("index = {0}", index));
        if (list == null || index >= list.Count)
            return defaultValue;
        return list[index];
    }
}