复杂的继承模式合同

我开始了与一个简单的数据模型：复杂的继承模式合同

{ 
    "Make" : "Honda", 
    "Model" : "Civic", 
    "Engine" : { 
     "Location" : "Front" 
    } 
}

这个对象满足我的使用情况，直到我得到了一个额外的要求，所以就成了：

{ 
    "Make" : "Honda", 
    "Model" : "Civic", 
    "FuelType" : "Gasoline", 
    "Engine" : { 
     "Location" : "Front", 
     "MPG" : 39 
    } 
}

{ 
    "Make" : "Tesla", 
    "Model" : "Model S", 
    "FuelType" : "Electric", 
    "Engine" : { 
     "Location" : "Back", 
     "Range" : 300 
    } 
}

现在，我知道我不能覆盖使用C＃派生返回类型，因此后续ING类的结构将无法正常工作：

abstract class Car { abstract Engine Engine; } 

class GasolineCar : Car { override GasolineEngine Engine; } 

class ElectricCar : Car { override ElectricEngine Engine; } 

abstract class Engine { string Location; } 

class GasolineEngine : Engine { int MPG; } 

class ElectricEngine : Engine { int Cells; }

是否有这个数据模式模型类似的推荐的方式？要求是：

我可以用JSON.NET
我可以使用基地车&发动机类型90％的时间，只投它需要特定类型的字段时，容易出现反序列化。

注意：请不要为上述示例特别提供备用解决方案。我对汽车一无所知，我真正的用例肯定需要使用这种模式或类似的东西。

来源

2016-03-01 Alex L

我认为你绝对会让你的课程复杂化。为什么不能简单的使用这些类，JSON的可以反序列化到这些类容易

class Car 
{ 
    public string Make { get; set; } 
    public string Model { get; set; } 
    public string FuelType { get; set; } 
    public Engine Engine { get; set; } 
} 

class Engine 
{ 
    public string Location { get; set; } 
    public string MPG { get; set; } 
    public string Range { get; set; } 
}

来源

2016-03-01 10:05:53

此特定场景无关紧要。如果两种引擎类型具有相同的字段名称但具有不同的数据类型会怎么样？ –

不知道我明白你的意思。引擎数据类型？在一天结束时，您需要一个可以映射到json对象的类。 json上的属性需要映射到类上的属性。如果json上有一个新的属性，那么这个类将会有一个新的属性。 –

一般方法是将这些覆盖拿到领域不能被重写。因此，您必须覆盖您的获取 - 设置方法

public abstract class Car { public virtual Engine Engine { get; set; } } 

public class GasolineCar : Car { 
    private GasolineEngine _engine; 
    public override Engine Engine { get { return _engine; } set { this._engine = (GasolineEngine)value; } } 
} 

public class ElectricCar : Car 
{ 
    private ElectricEngine _engine; 
    public override Engine Engine { get { return _engine; } set { this._engine = (ElectricEngine)value; } } 
} 
public abstract class Engine { public string Location; } 

public class GasolineEngine : Engine { int MPG; } 

public class ElectricEngine : Engine { int Cells; }

或者，如果类型限制是最重要的。

public abstract class Car<T> { public virtual T Engine { get; set; } } 

public class GasolineCar : Car<GasolineEngine> {} 

public class ElectricCar : Car<ElectricEngine>{} 
public abstract class Engine { public string Location; } 

public class GasolineEngine : Engine { int MPG; } 

public class ElectricEngine : Engine { int Cells; }

来源

2016-03-01 10:08:54

复杂的继承模式合同

回答

相关问题