设计原则 (6) 迪米特法则

简介

迪米特法则（Law of Demeter，LoD），也称为最少知识原则（Principle of Least Knowledge），是面向对象设计中的一个重要原则。它强调了一个对象应该对其他对象有尽可能少的了解，也就是说，一个对象不应该直接与其它对象进行过多的交互。简而言之，一个对象应该对其他对象保持最少的了解。

主要思想

1. 减少对象之间的依赖关系：迪米特法则要求对象之间尽可能地减少相互之间的交互，降低彼此之间的依赖关系，使得系统更加灵活、可维护和可扩展。

2. 降低耦合性：通过减少对象之间的直接交互，可以降低系统各个模块之间的耦合性，使得系统更容易理解、修改和扩展。

案例

不遵守迪米特法则的情况

假设有一个汽车制造工厂，其中包含汽车（Car）、引擎（Engine）和轮胎（Wheel）三个类。汽车需要获取引擎和轮胎的信息以及安装它们。

using System;

// 车轮类
public class Wheel
{
    public string Brand { get; set; }
}

// 引擎类
public class Engine
{
    public string Model { get; set; }
}

// 汽车类
public class Car
{
    private Engine engine;
    private Wheel wheel;

    public Car()
    {
        this.engine = new Engine();
        this.wheel = new Wheel();
    }

    // 安装引擎和轮胎
    public void InstallEngineAndWheel()
    {
        Console.WriteLine($"Installing engine model: {engine.Model}");
        Console.WriteLine($"Installing wheel brand: {wheel.Brand}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Car car = new Car();
        car.InstallEngineAndWheel();
    }
}

在这个例子中，汽车类直接创建了引擎和轮胎对象，并在自己的方法中直接使用它们。这样做导致了汽车类对引擎和轮胎的具体实现细节有了过多的了解，违反了迪米特法则。

遵守迪米特法则的情况

对比上面的例子，我们可以通过引入中间的装配者（Assembler）类来遵守迪米特法则。

using System;

// 装配者类
public class Assembler
{
    private Engine engine;
    private Wheel wheel;

    public Assembler(Engine engine, Wheel wheel)
    {
        this.engine = engine;
        this.wheel = wheel;
    }

    // 安装引擎和轮胎
    public void AssembleEngineAndWheel()
    {
        Console.WriteLine($"Assembling engine model: {engine.Model}");
        Console.WriteLine($"Assembling wheel brand: {wheel.Brand}");
    }
}

// 车轮类
public class Wheel
{
    public string Brand { get; set; }
}

// 引擎类
public class Engine
{
    public string Model { get; set; }
}

// 汽车类
public class Car
{
    private Assembler assembler;

    public Car(Assembler assembler)
    {
        this.assembler = assembler;
    }

    // 安装引擎和轮胎
    public void Assemble()
    {
        assembler.AssembleEngineAndWheel();
    }
}

class Program
{
    static void Main(string[] args)
    {
        Engine engine = new Engine { Model = "V6" };
        Wheel wheel = new Wheel { Brand = "Michelin" };
        Assembler assembler = new Assembler(engine, wheel);

        Car car = new Car(assembler);
        car.Assemble();
    }
}

在这个案例中，汽车类不再直接创建引擎和轮胎对象，而是通过装配者类来接收引擎和轮胎对象，然后调用装配者类的方法来安装引擎和轮胎。这样做遵守了迪米特法则，汽车类不再直接与引擎和轮胎交互，而是通过装配者类来进行间接的交互，降低了类之间的耦合度，提高了系统的灵活性和可维护性。

优点

1. 降低耦合度：降低系统中各个模块之间的耦合度，因为对象之间的直接依赖关系较少，对象之间的交互更加简单明了。
2. 提高模块的独立性：提高系统各个模块的独立性，每个模块只需要关注自己的核心功能，不需要关心其他模块的具体实现细节，从而降低了模块之间的耦合度。
3. 易于测试和调试：因为对象之间的依赖关系较少，模块之间的关系更加清晰明了，因此系统更易于测试和调试，能够快速定位和解决问题。
4. 增强可维护性和可扩展性：系统更加易于理解和维护，对象之间的依赖关系更加清晰，模块之间的关系更加简单明。每个模块都比较独立，易于修改和扩展，能够快速响应需求变化。

缺点

1. 引入中间层：可能需要引入额外的类或者中间层，例如委托一个中间对象来处理各个模块之间的通信，这可能会增加一些额外的设计和开发成本。
2. 可能造成过度设计：可能会导致过度设计，引入了不必要的类或者中间层，增加了系统的复杂度。需要在设计时进行权衡，避免过度设计。