依赖注入

引用自 https://www.cnblogs.com/ruanraun/p/Dependency.html

 

public class Person
    {

    }
    public class Me : Person
    {
        public void Work()
        {
            //……  省略若干代码
            iphone phone = new iphone();
            phone.Call();
            phone.Eamil();
        }

        public void Holiday()
        {
            //……  省略若干代码
            iphone phone = new iphone();
            phone.PlayGame();
            phone.VideoPlay();
            phone.Internet();
        }
    }

    public class iphone 
    {
        public void Call()
        {
            //……  省略若干代码
            Console.WriteLine($"iphone手机打电话");
        }

        public void Eamil()
        {
            //……  省略若干代码
            Console.WriteLine($"iphone手机发送邮件");
        }

        public void PlayGame()
        {
            //……  省略若干代码
            Console.WriteLine($"iphone手机玩游戏");
        }

        public void VideoPlay()
        {
            //……  省略若干代码
            Console.WriteLine($"iphone手机播放视频");
        }

        public void Internet()
        {
            //……  省略若干代码
            Console.WriteLine($"iphone手机上网");
        }
    }

调用

public class Program
    {
        public static void Main(string[] args)
        {
            int[] Holiday = { 0, 6 };
            //获取当前时间
            DateTime time = DateTime.Now;
            //实例化Me对象
            Me me = new Me();

            if (Holiday.Contains((int)time.DayOfWeek))
            {
                //如果当前时间为周六，周日，执行Holiday
                me.Holiday();
            }
            else
            {
                //如果当前时间不为周六，周日，执行Work
                me.Work();
            }
        }
    }

 

 

一个很简单的Iphone类，里面有若干方法，在一个Me类中，调用Iphone类中的方法，最大的问题是，如果我不用Iphone类了，那么需要改动的地方就很多。

public class Person
    {

    }
    public class Me : Person
    {
        private phone myphone;

        public Me(phone _phone)
        {
            myphone = _phone;
        }

        public void Work()
        {
            //……  省略若干代码
            myphone.Call();
            myphone.Eamil();
        }

        public void Holiday()
        {
            //……  省略若干代码
            myphone.PlayGame();
            myphone.VideoPlay();
            myphone.Internet();
        }
    }
    public abstract class phone
    {
        public abstract void Call();
        public abstract void Eamil();
        public abstract void PlayGame();
        public abstract void Internet();
        public abstract void VideoPlay();
    }

    public class iphone : phone
    {
        public override void Call()
        {
            //……  省略若干代码
            Console.WriteLine($"iphone手机打电话");
        }

        public override void Eamil()
        {
            //……  省略若干代码
            Console.WriteLine($"iphone手机发送邮件");
        }

        public override void PlayGame()
        {
            //……  省略若干代码
            Console.WriteLine($"iphone手机玩游戏");
        }

        public override void VideoPlay()
        {
            //……  省略若干代码
            Console.WriteLine($"iphone手机播放视频");
        }

        public override void Internet()
        {
            //……  省略若干代码
            Console.WriteLine($"iphone手机上网");
        }
    }

    public class huaweiphone : phone
    {
        public override void Call()
        {
            //……  省略若干代码
            Console.WriteLine($"华为手机打电话");
        }

        public override void Eamil()
        {
            //……  省略若干代码
            Console.WriteLine($"华为手机发送邮件");
        }

        public override void PlayGame()
        {
            //……  省略若干代码
            Console.WriteLine($"华为手机玩游戏");
        }

        public override void VideoPlay()
        {
            //……  省略若干代码
            Console.WriteLine($"华为手机播放视频");
        }

        public override void Internet()
        {
            //……  省略若干代码
            Console.WriteLine($"华为手机上网");
        }
    }

定义一个抽象类，在IPhone，HuaWei中继承并实现抽象方法。在Me的构造函数中去实例化抽象类。这样只需要在调用的地方实例化不同的派生类，根据传入的类，会调用相应的方法。

public class Program
    {
        public static void Main(string[] args)
        {
            int[] Holiday = { 0, 6 };
            //获取当前时间
            DateTime time = DateTime.Now;
            //实例化手机对象
            phone phone = new huaweiphone();
            //实例化Me对象
            Me me = new Me(phone);

            if (Holiday.Contains((int)time.DayOfWeek))
            {
                //如果当前时间为周六，周日，执行Holiday
                me.Holiday();
            }
            else
            {
                //如果当前时间不为周六，周日，执行Work
                me.Work();
            }
        }
    }

 

 如果一个类A 的功能实现需要借助于类B，那么就称类B是类A的依赖，如果在类A的内部去实例化类B，那么两者之间会出现较高的耦合，一旦类B出现了问题，类A也需要进行改造，如果这样的情况较多，每个类之间都有很多依赖，那么就会出现牵一发而动全身的情况，程序会极难维护，并且很容易出现问题。要解决这个问题，就要把A类对B类的控制权抽离出来，交给一个第三方去做，把控制权反转给第三方，就称作控制反转（IOC Inversion Of Control）。控制反转是一种思想，是能够解决问题的一种可能的结果，而依赖注入（Dependency Injection）就是其最典型的实现方法。由第三方（我们称作IOC容器）来控制依赖，把他通过构造函数、属性或者工厂模式等方法，注入到类A内，这样就极大程度的对类A和类B进行了解耦。

 

转载于:https://www.cnblogs.com/luyShare/p/11386350.html