Что предпочтительный путь состоит в том, чтобы сохранить различные версии данных?

Когда Вы пишете приложение, которое должно читать и работать с двумя версиями данных таким же образом, что лучший способ состоит в том, чтобы структурировать Ваши классы для представления тех данных. Я придумал три сценария:

1. Общая база / Определенные Дети
2. Объединение данных
3. Отличные структуры

Версия 1 Автомобильный пример

byte DoorCount
int Color
byte HasMoonroof
byte HasSpoiler
float EngineSize
byte CylinderCount

Версия 2 Автомобиль

byte DoorCount
int Color
enum:int MoonRoofType
enum:int TrunkAccessories
enum:int EngineType

Общая база / Определенные Дети

С этим методом существует базовый класс общих полей между двумя версиями данных и дочернего класса для каждой версии данных.

class Car {
    byte DoorCount;
    int Color;
}

class CarVersion1 : Car {
    byte HasMoonroof;
    byte HasSpoiler;
    float EngineSize;
    byte CylinderCount;
}

class CarVersion2 : Car {
    int MoonRoofType;
    int TrunkAccessories;
    int EngineType;
}

Преимущества

• Парадигма ООП

Слабые места

• Существующие дочерние классы должны будут измениться, если новая версия выпущена, который удаляет общее поле
• Данные для одной концептуальной единицы разделяются между двумя определениями не из-за любого подразделения, значимого для себя.

Объединение данных

Здесь, Автомобиль определяется как объединение полей Автомобиля через все версии данных.

class Car {
    CarVersion version;
    byte DoorCount;
    int Color;
    int MoonRoofType;     //boolean if Version 1
    int TrunkAccessories; //boolean if Version 1
    int EngineType;       //CylinderCount if Version 1
    float EngineSize;     //Not used if Version2
}

Преимущества

• Гм... Все находится в одном месте.

Слабые места

• Принудительный случай управляемый код.
• Трудный поддержать то, когда другая версия является выпуском или наследием, удалено.
• Трудный осмыслять. Значения полей изменяются на основе версии.

Отличные структуры

Здесь структуры не имеют никаких отношений ООП друг к другу. Однако интерфейсы могут быть реализованы обоими классами, если/когда код ожидает рассматривать их тем же способом.

class CarVersion1 {
    byte DoorCount;
    int Color;
    byte HasMoonroof;
    byte HasSpoiler;
    float EngineSize;
    byte CylinderCount;
}

class CarVersion2 {
    byte DoorCount;
    int Color;
    int MoonRoofType;
    int TrunkAccessories;
    int EngineType;
}

Преимущества

• Простой подход
• Легкий поддержать, если новая версия добавляется или наследие удалено.

Слабые места

• Это - антишаблон.

Существует ли лучший способ, которым я не думал? Вероятно, очевидно, что я одобряю последнюю методологию, но первый лучше?