设计原则 (5) 依赖倒置原则

简介

依赖倒置原则（Dependency Inversion Principle，DIP）是面向对象设计中的一个重要原则，它强调了高层模块不应该依赖于低层模块，二者都应该依赖于抽象；而且抽象不应该依赖于具体实现细节，具体实现细节应该依赖于抽象。简而言之，高层模块和低层模块都应该依赖于抽象，而不是依赖于具体的实现。

主要思想：

1. 高层模块与低层模块之间的解耦：高层模块和低层模块都应该依赖于抽象，而不是依赖于具体的实现细节，从而实现了高层模块与低层模块之间的解耦。

2. 抽象不应该依赖于具体实现细节：抽象应该定义接口或者抽象类，不应该依赖于具体的实现细节。具体的实现细节应该依赖于抽象，而不是反过来。

案例

不遵守依赖倒置原则的情况

假设我们有一个电子设备管理系统，其中有一个User类负责使用打印机来打印文件。首先我们看一个不遵守依赖倒置原则的设计：

    // 高层模块 User
    public class User
    {
        // 依赖于具体的低层模块 HPPrinter
        private HPPrinter printer = new HPPrinter();

        public void PrintDocument(string document)
        {
            printer.Print(document);
        }
    }

    // 低层模块 HPPrinter
    public class HPPrinter
    {
        public void Print(string document)
        {
            Console.WriteLine("Printing: " + document);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            User user = new User();
            user.PrintDocument("Document 1");
        }
    }

在这个设计中，User类直接依赖于具体的HPPrinter类，导致高层模块和低层模块之间存在了紧耦合关系，违背了依赖倒置原则。如果需要更换打印机体HPPrinter为XMPrinter，就需要修改User类的代码。

遵守依赖倒置原则的情况

using System;

    // 抽象接口 IPrinter
    public interface IPrinter
    {
        void Print(string document);
    }

    // 低层模块 HPPrinter 实现了 IPrinter 接口
    public class HPPrinter : IPrinter
    {
        public void Print(string document)
        {
            Console.WriteLine("Printing: " + document);
        }
    }

    // 低层模块 XMPrinter 实现了 IPrinter 接口
    public class XMPrinter : IPrinter
    {
        public void Print(string document)
        {
            Console.WriteLine("Printing: " + document);
        }
    }

    // 高层模块 User 依赖于抽象接口 IPrinter
    public class User
    {
        private IPrinter printer;

        // 通过构造函数注入打印机对象
        public User(IPrinter printer)
        {
            this.printer = printer;
        }

        public void PrintDocument(string document)
        {
            printer.Print(document);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 创建 Printer 对象并传递给 User 类
            //IPrinter hpPrinter = new HPPrinter();
            //改用XMPrinter打印机
            IPrinter xmPrinter = new XMPrinter();
            User user = new User(xmPrinter);
            user.PrintDocument("Document 1");
        }
    }

在这个设计中，User类依赖于抽象接口IPrinter，而不是具体的HPPrinter类。这样做使得User类不再依赖于具体的打印机实现，而是依赖于抽象的打印机接口，从而实现了高层模块和低层模块之间的解耦。如果需要更换打印机为XMPrinter，只需要修改依赖注入的部分，而不需要修改User类的代码，符合了依赖倒置原则。

优点

1. 降低耦合性：依赖倒置原则能够降低系统各个模块之间的耦合度，使得高层模块和低层模块之间的依赖关系更加松散，从而提高了系统的灵活性和可维护性。

2. 增强可扩展性：由于高层模块不依赖于具体的低层模块，而是依赖于抽象，因此系统更容易进行功能的扩展和修改，增强了系统的可扩展性和可维护性。

3. 提高代码的可读性和可维护性：依赖倒置原则使得代码的依赖关系更加清晰、简单，易于理解和维护，提高了代码的可读性和可维护性。

4. 提高代码的重用性：由于系统各个模块之间的依赖关系更加松散，因此模块的重用性也会增加，提高了代码的重用性和可复用性。

缺点

1. 增加设计和开发成本：遵循依赖倒置原则需要对系统进行合理的设计和抽象，可能会增加一些额外的设计和开发成本。

2. 增加学习成本：依赖倒置原则需要对面向对象设计原则有一定的了解，对开发人员的学习成本有一定的挑战。

3. 可能导致过度设计：为了遵循依赖倒置原则，可能会过度设计接口和抽象类，将一个功能细分为多个模块，这可能会增加系统的复杂度，降低系统的可理解性和可维护性。