多年以前，在我的刚接触编程语言时，我遇到了一个超出能力范围的类型设计问题。这个问题困扰我多年，让我寝食难安。原因并不是因为这个问题有多复杂，恰恰相反，让我纠结的是，这个问题看起来很简单，而我却找不到一个优秀的解决方法。
俗话说踏破铁鞋无觅处，得来全不费工夫。苦苦求索而不得的多年之后，我从一次系统设计过程中得到了启发，我终于想出了一个激动人心的解决方案。本文除了吹吹牛逼告诉你们我从几年前开始考虑代码的细节外，我还想和你们分享一下我的激动人心的优秀解决方案的产生过程。
问题所在
现在已有一个汽车类，我们需要获取关于发动机的信息。发动机的种类有很多种。我们可以有一个柴油发动机，一个V型发动机，一个直列式发动机，诸如此类。
事实上，作为程序猿的我对汽车发动机一无所知。
问题是：如何在代码中表示我们的发动机类型？
我希望我表示的发动机类型具有很多功能。发动机类型用EngineType表示，这个类应该包含以下功能：
- 获取马力值：GetHorsePower()
- 获取价格：GetPrice()
- 获取二手价格：GetPriceForUsed(int yearsOld)
- 根据车身重量计算加速度：CalculateAccelerationWithCarWeight(int carWeight)
- ......
1#方案：继承
我们可以为发动机建立基类，然后汽车将继承这些基类。
public abstract class DieselEngineCar : ICar
{
public int GetHorsePower() { return 80; }
public int GetPrice() { return 5000; }
}
public abstract class V8EngineCar : ICar
{
public int GetHorsePower() { return 200; }
public int GetPrice() { return 20000; }
}
public class Toyota : V8EngineCar
{
}
这确实可行，但感觉不是那么回事。
如果我们想添加GearType和WheelsType呢？我们总不能在C＃中使用多重继承吧？即使我能采用这种做法，这种设计也是有缺陷的。发动机是汽车的一部分，但汽车并不是发动机的一个子类。
那么我们来看看2#方案。
2#方案：枚举
我们将构造一个枚举，并列举出我们所有的发动机类型。
ICar将有一个EngineType属性
public enum EngineType { Diesel, V8, Straight, Boxer }
public interface ICar
{
EngineType Engine { get; }
}
这样就好多了。但是，Car.Engine.GetPrice()或Car.Engine.GetHorsePower()该要如何实现呢？
首先想到的是我们枚举的扩展方法：
public static int GetPrice(this EngineType engineType)
{
switch(engineType)
{
case EngineType.Diesel: return 5000;
case EngineType.Boxer: return 10000;
default:
case EngineType.V8:
return 20000;
}
}
public static int GetHorsePower(this EngineType engineType)
{
switch (engineType)
{
case EngineType.Diesel: return 80;
case EngineType.Boxer: return 100;
default:
case EngineType.V8:
return 200;
}
}
好吧，这样确实可以达到我要的效果，但有些鸡肋，因为我们在代码中将会包含有很多switch-case判断语句。每当我们添加一个新的发动机类型，我们将不得不去switch下的case中添加新的发动机。如果我们忘了呢？此外，我们是面向对象的编程，这种通过switch控制并不是很“面向对象”......
让我们尝试解决方法，看看解决方案3#......
3#解决方案：类
园友们太熟悉不过了，实现起来应该也是相当简单的吧？
public interface ICar
{
IEngineType Engine { get; }
}
public interface IEngineType
{
int Price { get; }
int HorsePower { get; }
}
public class V8Engine : IEngineType
{
public int HorsePower { get { return 200; } }
public int Price { get { return 20000; } }
}
public class Hyundai : ICar
{
public Hyundai()
{
Engine = new V8Engine();
}
public IEngineType Engine { get; set; }
}
如果满分100分的话，这样的实现可以打80分了。但是，还是有一些可以改进的地方。
- 为什么我需要创建一个V8Engine的新实例？ 它总是一样的...看起来很浪费
- 我如何比较两个引擎？ 我需要类似的东西
if（engine1.GetType（）== engine2.GetType（））
确实是个问题！如果我把我所有的class换成Singletons会怎样呢？
public class V8Engine : IEngineType
{
private static readonly Lazy<V8Engine> _instance =
new Lazy<V8Engine>(() => new V8Engine());
public static V8Engine Instance => _instance.Value;
private V8Engine()
{
}
public int HorsePower { get { return 200; } }
public int Price { get { return 20000; } }
}
我更倾向于这种解决方案。比较两个引擎时，我可以使用简单的=运算符，因为这儿只有一个实例。
要是说还有缺陷的话，那就是任何人都可以从IEngine继承并创建自己的自定义EngineType。
如果你了解Java，你可能会想“在Java中，我只需扩展我的枚举。“。但对不起，C#中并不支持这么做。
事实上，在Java中这是很容易解决的:
public enum Level {
HIGH (3),
MEDIUM(2),
LOW (1) ;
private final int levelCode;
Level(int levelCode) {
this.levelCode = levelCode;
}
public int getLevelCode() {
return this.levelCode;
}
}
哈哈很酷是不是？
4#方案：类Java枚举
用一个小小的魔法嵌套类，你可以达到这个目的。
public abstract class EngineType
{
public static EngineType V8 = new V8EngineType();
public static EngineType Diesel = new DieselEngineType();
private EngineType()
{
}
public abstract int Price { get; }
public abstract int HorsePower { get; }
public class V8EngineType : EngineType
{
public override int HorsePower { get { return 200; } }
public override int Price { get { return 20000; } }
}
public class DieselEngineType : EngineType
{
public override int HorsePower { get { return 80; } }
public override int Price { get { return 5000; } }
}
}
或者是这样：
public class EngineType
{
public static EngineType V8 = new EngineType(20000, 200);
public static EngineType Diesel = new EngineType(5000, 80);
private EngineType(int price, int horsePower)
{
Price = price;
HorsePower = horsePower;
}
public int Price { get; private set; }
public int HorsePower { get; private set; }
}
构造函数应该是私有的，这样这个类中的任何人都不能创建一个新的EngineType。
如此一来，我的类型设计问题得到了有效的解决。
其实还有一个技巧，就是我们可以使用带有属性的常规枚举，例如：
public enum EngineType
{
[EngineAttr(80, 5000)]
Boxer,
[EngineAttr(100, 10000)]
Straight,
[EngineAttr(200, 20000)]
V8
}
通过扩展方法，我们也可以访问这个枚举类的属性值。
程序代码：https://github.com/daivven/TypeDesign
博客地址：http://www.cnblogs.com/yayazi/
本文地址：http://www.cnblogs.com/yayazi/p/8383485.html
声明：本博客原创文字允许转载，转载时必须保留此段声明，且在文章页面明显位置给出原文链接。