设计模式—依赖倒置原则(DIP)

1.概念

依赖倒置原则(Dependence Inversion Principle)是程序要依赖于抽象接口,不要依赖于具体实现。简单的说就是要求对抽象进行编程,不要对实现进行编程,这样就降低了客户与实现模块间的耦合。

通俗的讲:

  1. 要面向抽象编程,而不是面向细节编程;

  2. 高层模块不应该依赖底层模块,二者应该通过抽象依赖,而不是依赖细节;

  3. 抽象不应该依赖于具体,具体应该依赖于抽象。

设计模式—依赖倒置原则(DIP)_第1张图片

2.案例分析

需求:我们要开发一套自动驾驶系统,只要在汽车上安装该系统就可以实现自动驾驶,该系统目前只支持在福特和本田车上使用。

优化前版本(不满足依赖倒置原则):

设计模式—依赖倒置原则(DIP)_第2张图片

/// 
    /// 福特车
    /// 
    public class FordCar
    {
        public void Run()
        {
            Console.WriteLine("福特开始启动了");
        }
        public void Turn()
        {
            Console.WriteLine("福特开始转弯了");
        }
        public void Stop()
        {
            Console.WriteLine("福特开始停车了");
        }
    }

/// 
    /// 本田车
    /// 
    public class HondaCar
    {
        public void Run()
        {
            Console.WriteLine("本田开始启动了");
        }
        public void Turn()
        {
            Console.WriteLine("本田开始转弯了");
        }
        public void Stop()
        {
            Console.WriteLine("本田开始停车了");
        }
    }

/// 
    /// 自动驾驶
    /// 
    public class AutoSystem
    {
        private HondaCar hcar = new HondaCar();
        private FordCar fcar = new FordCar();
        private CarType type;
        public AutoSystem(CarType type)
        {
            this.type = type;
        }
        
        /// 
        /// 启动
        /// 
        public void RunCar()
        {
            if (type == CarType.Ford)
            {
                fcar.Run();
            }
            else
            {
                hcar.Run();
            }
        }

        /// 
        /// 转弯
        /// 
        public void TurnCar()
        {
            if (type == CarType.Ford)
            {
                fcar.Turn();
            }
            else
            {
                hcar.Turn();
            }
        }

        /// 
        /// 停车
        /// 
        public void StopCar()
        {
            if (type == CarType.Ford)
            {
                fcar.Stop();
            }
            else
            {
                hcar.Stop();
            }
        }

        public enum CarType : int
        {
            [Description("福特车")]
            Ford = 0,
            [Description("本田车")]
            Honda = 1,
        };
    }

{
        //DIP:依赖倒置原则
        //福特车
        AutoSystem fordAutoSystem = new AutoSystem(CarType.Ford);
        fordAutoSystem.RunCar();
        fordAutoSystem.TurnCar();
        fordAutoSystem.StopCar();

        //本田车
        AutoSystem hondaAutoSystem = new AutoSystem(CarType.Honda);
        hondaAutoSystem.RunCar();
        hondaAutoSystem.TurnCar();
        hondaAutoSystem.StopCar();
    }

设计模式—依赖倒置原则(DIP)_第3张图片

代码分析:

上面的程序确实能够实现针对Ford和Honda车的无人驾驶,但是在实际的生成场景中需求是不断变化的,比如我们现在又增加了一个新的合作伙伴:宝马车,那我们就需要新定义一个宝马车的实现类,以及对应的枚举CarType和上层的AutoSystem类都需要跟着修改,当随着越来越多的车企加入我们,那我们当前的设计就会变得僵化、脆弱。

如何优化?

导致上面所述问题的一个原因是:含有高层策略的utoSystem模块,依赖于它所控制的低层的具体细节的模块:HondaCar和FordCar。如果我们能够找到一种方法使AutoSystem模块独立于它所控制的具体细节,那么我们就可以自由地复用它了。我们就可以用这个模块来生成其它的程序,使得系统能够用在需要的汽车上。毋庸置疑那就该我们的依赖倒置原则出场了。

优化后的版本(满足依赖倒置原则):

设计模式—依赖倒置原则(DIP)_第4张图片

/// 
    /// 接口层
    /// 
    public interface ICar
    {
        void Run();

        void Turn();

        void Stop();
    }

 /// 
    /// 福特车
    /// 
    public class FordCarDIP : ICar
    {
        public void Run()
        {
            Console.WriteLine("福特开始启动了");
        }

        public void Turn()
        {
            Console.WriteLine("福特开始转弯了");
        }

        public void Stop()
        {
            Console.WriteLine("福特开始停车了");
        }
    }

/// 
    /// 本田车
    /// 
    public class HondaCarDIP : ICar
    {
        public void Run()
        {
            Console.WriteLine("本田开始启动了");
        }

        public void Turn()
        {
            Console.WriteLine("本田开始转弯了");
        }

        public void Stop()
        {
            Console.WriteLine("本田开始停车了");
        }
    }

    /// 
    /// 自动驾驶
    /// 
    public class AutoSystemDIP
    {
        private ICar icar;
        public AutoSystemDIP(ICar icar)
        {
            this.icar = icar;
        }
        
        /// 
        /// 启动
        /// 
        public void RunCar()
        {
            icar.Run();
        }

        /// 
        /// 拐弯
        /// 
        public void TurnCar()
        {
            icar.Turn();
        }

        /// 
        /// 停车
        /// 
        public void StopCar()
        {
            icar.Stop();
        }
    }

 {
        //DIP:依赖倒置原则
        //福特车
        ICar car = new FordCarDIP();
        AutoSystemDIP fordAutoSystem = new AutoSystemDIP(car);
        fordAutoSystem.RunCar();
        fordAutoSystem.TurnCar();
        fordAutoSystem.StopCar();

        //本田车
        car = new HondaCarDIP();
        AutoSystemDIP hondaAutoSystem = new AutoSystemDIP(car);
        hondaAutoSystem.RunCar();
        hondaAutoSystem.TurnCar();
        hondaAutoSystem.StopCar();
    }

代码分析:

AutoSystem系统依赖于ICar 这个抽象,而与具体的实现细节HondaCar、FordCar无关,所以实现细节的变化不会影响AutoSystem。对于实现细节只要实现ICar 即可,即实现细节依赖于ICar 抽象。

3.优缺点

优点:

  1. 降低类与类之间的耦合性;

  2. 增强系统的稳定性;

  3. 提高代码的可读性和维护性;

  4. 降低修改代码带来的风险;

缺点:

除了抽象难度大点、需要对功能业务理解透彻以外,几乎无缺点,依赖倒置还是我们开发中使用比较频繁的一个原则。

设计模式—依赖倒置原则(DIP)_第5张图片

你可能感兴趣的:(设计模式,设计模式,依赖倒置原则,c#,java,后端,前端)