IoC原理及实现

什么是IoC

IoC是Inversion of Control的缩写，翻译过来为“控制反转”。简单来说，就是将对象的依赖关系交由第三方来控制。在理解这句话之前，我们先来回顾一下IoC的演化。

Ioc前生今世

传统的new class的方式
我们写了一个ChineseSpeaker的类，他有一个SayHello的方法并调用输出控制台：

 class Program
        {
            static void Main(string[] args)
            {
                ChineseSpeaker chineseSpeaker= new ChineseSpeaker();
                chineseSpeaker.SayHello();
            }
        }

        public class ChineseSpeaker
        {
            public void SayHello()
            {
                Console.WriteLine("你好！！！");
            }
        }

上面看起来没有任何问题，一切都很好，但是有一天英国演讲者打招呼的话，我们就需要新建了一个BritishSpeaker类：

class Program
        {
            static void Main(string[] args)
            {
                //ChineseSpeaker chineseSpeaker = new ChineseSpeaker();
                //chineseSpeaker.SayHello();

                BritishSpeaker britishSpeaker = new BritishSpeaker();
                britishSpeaker.SayHello();
            }
        }

        public class BritishSpeaker
        {
            public void SayHello()
            {
                Console.WriteLine("Hello!!!");
            }
        }

        //ChineseSpeaker 同上面的代码一样

到目前为止，代码已经暴露出设计原则中要避免的问题：松耦合（loose coupling）。程序中非常依赖实际的class，这导致了：

当出现“日本人”、“印度人”时，我们不得不修改和重新编译代码。当程序代码和逻辑不复杂的时候问题不大，但当程序变大的时候程序猿就苦逼了。

Interface方式

为了避免这种直接依赖关系，我们需要把对象或行为抽象出来一个东西，叫做接口（interface）。它就像电脑中的usb插口，无论是优盘还是鼠标只要插头是usb的我就能使用，从而屏蔽了复杂性。

因此，我们把代码改成：

        public interface ISpeak
        {
            void SayHello();
        }

        public class BritishSpeaker : ISpeak
        {
            public void SayHello()
            {
                Console.WriteLine("Hello!!!");
            }
        }

        public class ChineseSpeaker : ISpeak
        {
            public void SayHello()
            {
                Console.WriteLine("你好！！！");
            }
        }

因为我们现在把类的实现和功能拆出来了，所以我们可以让客户端动态的来选择谁SayHello

class Program
       {
           static void Main(string[] args)
           {
               //ChineseSpeaker chineseSpeaker = new ChineseSpeaker();
               //chineseSpeaker.SayHello();
               //BritishSpeaker britishSpeaker = new BritishSpeaker();
               //britishSpeaker.SayHello();

               ISpeak speak;

               if (args.Length > 0 && args[0] == "Chinese")
               {
                   speak = new ChineseSpeaker();
               }
               else
               {
                   speak = new BritishSpeaker();
               }

               speak.SayHello();
           }
       }

这时候我们不知不觉的用到了面向对象六大原则中的依赖倒转原则（DIP），高层模块不依赖于低层模块的实现，而低层模块依赖于高层模块定义的接口。好，让我们回到IoC，比较上面的两种写法：

传统的写法类在定义的瞬间就已经决定具体的类型，他的流程是从上到下的
使用interface的写法是在实例化时才决定类的具体类型，也就是用到的时候才会new（）,他的流程是new后面来控制的

这时候我们再来看IoC的意思是控制反转，就能大概理解了。传统的写法流程属于从上到下，而interface写法则是由new()其他的类来决定类的实现，因此控制的流程反转了。

DI是什么

利用interface的方式，可以让类在使用的时候再决定由哪个具体类来实现。那该如何实现这种方式呢？这时就有一个新的名称出现了，就是Dependency Injection(依赖注入)，简称DI。DI有三种方式，分别是构造函数注入、属性注入、接口注入

构造函数注入

  public class Printer
        {
            private ISpeak _speak;
            public Printer(ISpeak speak)//构造函数注入
            {
                _speak = speak;
            }
        }

        class Program
        {
            static void Main(string[] args)
            {
                //ChineseSpeaker chineseSpeaker = new ChineseSpeaker();
                //chineseSpeaker.SayHello();
                //BritishSpeaker britishSpeaker = new BritishSpeaker();
                //britishSpeaker.SayHello();

                //ISpeak speak;

                //if (args.Length > 0 && args[0] == "Chinese")
                //{
                //    speak = new ChineseSpeaker();
                //}
                //else
                //{
                //    speak = new BritishSpeaker();
                //}

                //speak.SayHello();

                Printer print;

                if (args.Length > 0 && args[0] == "Chinese")
                {
                    print = new Printer(new ChineseSpeaker());
                }
                else
                {
                    print = new Printer(new BritishSpeaker());
                }

            }
        }

属性注入

public class Printer
{
    public ISpeak Speaker { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        //ChineseSpeaker chineseSpeaker = new ChineseSpeaker();
        //chineseSpeaker.SayHello();
        //BritishSpeaker britishSpeaker = new BritishSpeaker();
        //britishSpeaker.SayHello();

        //ISpeak speak;

        //if (args.Length > 0 && args[0] == "Chinese")
        //{
        //    speak = new ChineseSpeaker();
        //}
        //else
        //{
        //    speak = new BritishSpeaker();
        //}

        //speak.SayHello();

        Printer print = new Printer();
        if (args.Length > 0 && args[0] == "Chinese")
        {
            print.Speaker = new ChineseSpeaker();
        }
        else
        {
            print.Speaker = new BritishSpeaker();
        }
    }
}

接口注入

    //接口注入
        public interface IPrint
        {
            void SetSpeaker(ISpeak speak);
        }

        public class Printer : IPrint
        {
            private ISpeak _speak;
            public void SetSpeaker(ISpeak speak)
            {
                _speak = speak;
            }
        }

        class Program
        {
            static void Main(string[] args)
            {
                //ChineseSpeaker chineseSpeaker = new ChineseSpeaker();
                //chineseSpeaker.SayHello();
                //BritishSpeaker britishSpeaker = new BritishSpeaker();
                //britishSpeaker.SayHello();

                ISpeak speak;

                if (args.Length > 0 && args[0] == "Chinese")
                {
                    speak = new ChineseSpeaker();
                }
                else
                {
                    speak = new BritishSpeaker();
                }

                Printer printer = new Printer();
                printer.SetSpeaker(speak);
            }
        }

IoC与DI的关系

我的理解是IoC是一种理念，DI则是它的具体实现方式

IoC Container

IoC Container帮我们在项目运行时动态的创建实例，它主要功能如下：