[有格式的原文请到https://www.cnc6.cn/c六大设计原则/文末下载]
软件设计原则常见的有6大原则，分别为：
①单一职责原则；
②开闭原则；
③依赖倒置原则；
④里氏替换原则；
⑤接口隔离原则；
⑥迪米特法则。
使用C#编程方式，并结合仪器（Instrument）编程，对以上设计原则进行讲解。
一、单一职责原则
简述：类职责要单一，不能有多个职责，具有多个职责的类要进行拆分，形成单一职责的类。
C#代码如下：
class DCPowerSupply
{
public void On() { }
public void Off() { }
public double Voltage { set; get; }
public double Current { set; get; }
public void Record(string content)
{
//记录操作
}
}
以上代码中，函数Off、On、Voltage、Current都是属于DCPowerSupply类的职责，但函数Record并不属于DCPowerSupply的职责，因此，需要将Record函数重新形成一个新类，并应用到该类中，新修改的C#代码如下：
class DCPowerSupply
{
public void On() { }
public void Off() { }
public double Voltage { set; get; }
public double Current { set; get; }
}
class Log
{
public void Record(string content)
{
//记录操作
}
}
客户端代码如下：
class Program
{
static void Main(string[] args)
{
DCPowerSupply dcPowerSupply = new DCPowerSupply();
dcPowerSupply.Voltage = 5;
dcPowerSupply.On();
Log log = new Log();
log.Record($"DCPowerSupply:{dcPowerSupply.Voltage},On");
}
}
从以上代码可以看出，原本耦合性很强的DCPowerSupply中的函数Record，已经从该类中进行解耦，形成松耦合的代码，复用性更强。
二、开闭原则
简述：对类的操作，拓展的要开放，修改的要关闭，类一旦写好并运行OK，就不要轻易去变动它，利用面向对象编程的继承特性，可以很好地对所需要增加的功能进行拓展。
C#代码如下：
class ACPowerSupply
{
public void On() { }
public void Off() { }
public double Voltage { set; get; }
public double Current { set; get; }
}
现在需要在ACPowerSupply类加入测量功率因素（PowerFactor）的功能，如果像这样修改ACPowerSupply类，C#代码如下：
class ACPowerSupply
{
public void On() { }
public void Off() { }
public double Voltage { set; get; }
public double Current { set; get; }
public double PowerFactor { set; get; }
}
那就会违背了开闭原则，因ACPowerSupply类已经写好，如果要增加功能，可以新编写一个名为ACPowerSupplyEx的类，继承自ACPowerSupply，并在其中加入PowerFactor的功能即可。
C#代码如下：
class ACPowerSupplyEx:ACPowerSupply
{
public double PowerFactor { set; get; }
}
三、依赖倒置原则
简述：抽象不依赖于具体细节，具体细节依赖抽象，要面向抽象编程，不要面向实现编程。说的简单点，无论是变量声明、返回值、还是参数，其类型都是抽象的，而不是具体的。
鉴于以上特点：
①每个类尽量继承自接口或抽象类、或两者的结合体；
②每个类不应该从具体类派生；
③由于有使用继承，尽量参照里氏替换原则（以下第四点所述）。
C#代码如下：
class PowerSupply
{
public void On() { }
public void Off() { }
public double Voltage { set; get; }
public double Current { set; get; }
}
class DCPowerSupply: PowerSupply
{
public double Power { set; get; }
}
class ACPowerSupply: PowerSupply
{
public double PowerFactor { set; get; }
}
class PowerSupplySeller
{
public void Sell(ACPowerSupply powerSupply)
{
//卖AC电源
}
public void Sell(DCPowerSupply powerSupply)
{
//卖DC电源
}
}
客户端代码如下：
class Program
{
static void Main(string[] args)
{
PowerSupplySeller seller = new PowerSupplySeller();
seller.Sell(new ACPowerSupply());
//下次想卖DC电源产品，就不得不在PowerSupplySeller类写入一个重载版的Sell方法，违背了开闭原则
}
}
正确的C#代码如下（只需对public void Sell(ACPowerSupply powerSupply)进行修改即可）：
class PowerSupplySeller
{
public void Sell(PowerSupply powerSupply)
{
//卖AC或DC电源
}
}
客户端代码如下：
class Program
{
static void Main(string[] args)
{
PowerSupplySeller seller = new PowerSupplySeller();
seller.Sell(new ACPowerSupply());
seller.Sell(new DCPowerSupply());
}
}
以上不仅仅体现在形参上，还体现在方法或属性的返回值、字段类型等。
四、里氏替换原则
简述：可以使用父类的类型来代替子类的类型，但不改变子类的行为，继承必须确保父类所拥有的性质在子类中仍然成立。
C#代码如下：
class Meter
{
public double Voltage
{
get
{
//模仿返回一个值，这里以5.01V为准
double value = 5.01;
Console.WriteLine($"DigitalMeter,Voltage:{value}");
return value;
}
}
public double Current
{
get
{
//模仿返回一个值，这里以1.001A为准
double value = 1.001;
Console.WriteLine($"DigitalMeter,Current:{value}");
return value;
}
}
}
class DigitalMeter: Meter
{
}
class DCPowerSupply : Meter
{
public double Voltage
{
get
{
//模仿返回一个值，这里以12.02V为准
double value = 12.02;
Console.WriteLine($"DCPowerSupply,Voltage:{value}");
return value;
}
}
public double Current
{
get
{
//模仿返回一个值，这里以2.002A为准
double value = 2.002;
Console.WriteLine($"DCPowerSupply,Current:{value}");
return value;
}
}
}
客户端代码如下：
class Program
{
static void Main(string[] args)
{
Meter meter1 = new DigitalMeter();
Meter meter2 = new DCPowerSupply();
var voltage1 = meter1.Voltage;
var voltage2 = meter2.Voltage;
var current1 = meter1.Current;
var current2 = meter2.Current;
}
}
运行结果如下：
从以上可以看出，本来为DCPowerSupply的类，既然输出了Meter的信息，这就违背了里氏替换原则。
新修改的代码如下：
interface IMeter
{
double Voltage { get; }
double Current { get; }
}
class Meter: IMeter
{
public double Voltage
{
get
{
//模仿返回一个值，这里以5.01V为准
double value = 5.01;
Console.WriteLine($"DigitalMeter,Voltage:{value}");
return value;
}
}
public double Current
{
get
{
//模仿返回一个值，这里以1.001A为准
double value = 1.001;
Console.WriteLine($"DigitalMeter,Current:{value}");
return value;
}
}
}
class DigitalMeter: Meter
{
}
class DCPowerSupply : IMeter
{
public double Voltage
{
get
{
//模仿返回一个值，这里以12.02V为准
double value = 12.02;
Console.WriteLine($"DCPowerSupply,Voltage:{value}");
return value;
}
}
public double Current
{
get
{
//模仿返回一个值，这里以2.002A为准
double value = 2.002;
Console.WriteLine($"DCPowerSupply,Current:{value}");
return value;
}
}
}
客户端代码如下：
class Program
{
static void Main(string[] args)
{
IMeter meter1 = new DigitalMeter();
IMeter meter2 = new DCPowerSupply();
var voltage1 = meter1.Voltage;
var voltage2 = meter2.Voltage;
var current1 = meter1.Current;
var current2 = meter2.Current;
}
}
运行结果如下：
从以上代码可以看出，用父类代替子类时，不能影响其子类的行为，否则，就违背了里氏替换原则。
五、接口隔离原则
简述：要让接口尽量简单，功能一致的可以写在仪器，与接口无关的必须重新写接口，也就是说，不要让接口变得臃肿。
C#代码如下：
interface IInstrument
{
void Write(string command);
string Read();
double Voltage { get; }
double Current { get; }
}
以上代码有两组，一组为Write、Read，另外一组为Voltage、Current，按照功能分类的话，Write、Read应属于端口的读写，而Voltage、Current则为电表的读电压、读电流，按照接口隔离原则，需要进行隔离。
修改后的代码如下：
interface IPort
{
void Write(string command);
string Read();
}
interface IMeter
{
double Voltage { get; }
double Current { get; }
}
六、迪米特法则
简述：类A、类B之间本身没有直接关联关系，那么就不能相互调用，可以通过第三个类（类C）进行间接调用，降低类A与类B的耦合性，提高模块的相对独立性。
C#代码如下：
class DCPowerSupply
{
public Port Port { set; get; }
public double Voltage
{
set
{
Port.Write($"Voltage:{value}");
}
get
{
return Convert.ToDouble(Port.Read());
}
}
public double Current
{
set
{
Port.Write($"Current:{value}");
}
get
{
return Convert.ToDouble(Port.Read());
}
}
public void On() { }
public void Off() { }
}
class Port
{
public void Write(string command)
{
}
public string Read()
{
return new Random().NextDouble().ToString();
}
}
以上代码，Port类与DCPowerSupply类进行了相互调用，耦合性很强，改变其中一个类的方法，对调用的那个类有很大的影响。
修改之后的代码如下：
class DCPowerSupply
{
public double Voltage { set; get; }
public double Current { set; get; }
public void On() { }
public void Off() { }
}
class Port
{
public void Write(string command)
{
}
public string Read()
{
return new Random().NextDouble().ToString();
}
}
class DCPowerSupplyWithPort
{
DCPowerSupply powerSupply;
Port port;
public DCPowerSupplyWithPort()
{
powerSupply = new DCPowerSupply();
port = new Port();
}
public double Voltage
{
set
{
port.Write($"Voltage:{value}");
}
get
{
return Convert.ToDouble(port.Read());
}
}
public double Current
{
set
{
port.Write($"Current:{value}");
}
get
{
return Convert.ToDouble(port.Read());
}
}
public void On()
{
powerSupply.On();
}
public void Off()
{
powerSupply.Off();
}
}
以上代码，可以将Port类与DCPowerSupply类进行分离，使用了第三个类DCPowerSupplyWithPort，使得Port类与DCPowerSupply类松耦合，独立性强，符合迪米特法则，同样，该法则还适用于三层架构。