C# IoC學習筆記_ZenDei技術網路在線

一、引言 IoC-Invertion of Control，即控制反轉，是一種程式設計思想。先初步瞭解幾個概念：依賴（Dependency）：就是有聯繫，表示一個類依賴於另一個類。依賴倒置原則（DIP）：設計模式六大原則之一，是一種軟體架構設計原則。控制反轉（IoC）：一種軟體設計原則，上層 ...

一、引言

IoC-Invertion of Control，即控制反轉，是一種程式設計思想。

先初步瞭解幾個概念：

依賴（Dependency）：就是有聯繫，表示一個類依賴於另一個類。

依賴倒置原則（DIP）：設計模式六大原則之一，是一種軟體架構設計原則。

控制反轉（IoC）：一種軟體設計原則，上層對下層的依賴（即底層模塊的獲得）交給第三方。

依賴註入（DI）：實現IoC的一種方式、手段。

IoC容器：依賴註入的框架，用來映射依賴，管理對象的創建和生存周期。

二、依賴

依賴就是有聯繫，有地方使用它就是有依賴它，下麵看一個簡單的示例：

    class Program
    {
        class BMW
        {
            public string Show()
            {
                return "寶馬";
            }
        }
        class ChinesePeople
        {
            private BMW bmw = new BMW();
            public void Run()
            {
                Console.WriteLine($"今天開{bmw.Show()}上班");
            }
        }

        static void Main(string[] args)
        {
            ChinesePeople people = new ChinesePeople();
            BMW bmw = new BMW();
            people.Run();
            Console.Read();
        }
    }

View Code

上面中國人開著寶馬去上班，客戶端有使用中國人、寶馬汽車兩個對象，中國人中有使用對象寶馬汽車，我們可以從中找到三個依賴關係：

客戶端依賴對象ChinesePeople；

客戶端依賴對象BMW；

ChinesePeople依賴對象BMW；

三、依賴倒置原則

過些日子來了新需求，中國人不僅要開寶馬去上班，還要開賓士去上班，如果按照上面直接依賴關係的方式去做，我們就需要修改ChinesePeople類，讓它實現一個參數為寶馬的重載方法Run()。顯然這樣不是好的設計，我們總不能每次新增一種汽車（即修改下層模塊）都要去修改ChinesePeople類吧（相對於汽車為上層模塊），太麻煩了。。。

先簡單分析一下，耦合關係就是依賴關係，如果依賴關係很重，牽一發而動全身，將很難維護擴展，耦合關係越少，系統會越穩定，因此要較少依賴。

定義：

A.高層模塊不應依賴於底層模塊，兩者應該依賴於抽象。

B.抽象不應該依賴於細節，細節應該依賴於抽象。

在這個圖中，我們發現高層模塊定義介面，將不直接依賴於下層模塊，下層模塊負責實現高層模塊定義的介面，下麵看一下示例：

    class Program
    {
        interface ICar
        {
            string Show();
        }

        class BMW : ICar
        {
            public string Show()
            {
                return "寶馬";
            }
        }

        class BenZ : ICar
        {
            public string Show()
            {
                return "賓士";
            }
        }

        interface IPeople
        {
            void Run(ICar car);
        }

        class ChinesePeople : IPeople
        {
            public void Run(ICar car)
            {
                Console.WriteLine($"今天開{car.Show()}上班");
            }
        }

        static void Main(string[] args)
        {
            ICar bmw = new BMW();
            ICar benz = new BenZ();
            IPeople people = new ChinesePeople();
            people.Run(bmw);
            people.Run(benz);
            Console.Read();
        }
    }

View Code

運行結果如下：

分析：上面代碼中，ChinesePeople類不再依賴於具體的汽車，而是依賴於汽車的抽象，這樣使得不管換什麼樣的汽車品牌，中國人都是可以開著去上班的，而且不需要修改ChinesePeople類。想一下，這樣是不是挺好的，我們可以得出：上層不再依賴細節，相比面向實現，面向介面較好，因為抽象相比細節要更穩定。

四、控制反轉

上面示例中，我們實現了具體的人和具體的汽車的隔離，具體人只和汽車的介面有關。但是Program中Main方法里的具體對象寫死了，控制權變小，當我要修改美國人開著福特去上班時，就不得不要去修改代碼，那怎麼把控制權轉移呢？

下麵看一個簡單的示例(請先添加System.Configuration引用)：

    interface ICar
    {
        string Show();
    }

ICar.cs

    interface IPeople
    {
        void Run(ICar car);
    }

IPeople.cs

    class BMW : ICar
    {
        public string Show()
        {
            return "寶馬";
        }
    }

BMW.cs

    class ChinesePeople : IPeople
    {
        public void Run(ICar car)
        {
            Console.WriteLine($"今天開{car.Show()}上班");
        }
    }

ChinesePeople.cs

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
    </startup>
    <appSettings>
        <add key="People" value="LinkTo.Test.ConsoleIoC.ChinesePeople,LinkTo.Test.ConsoleIoC"/>
        <add key="Car" value="LinkTo.Test.ConsoleIoC.BMW,LinkTo.Test.ConsoleIoC"/>
    </appSettings>
</configuration>

App.config

    class Program
    {
        static void Main(string[] args)
        {
            #region 反射+配置文件實現Ioc
            string people = ConfigurationManager.AppSettings["People"];
            string car = ConfigurationManager.AppSettings["Car"];
            Assembly assemblyPeople = Assembly.Load(people.Split(',')[1]);
            Assembly assemblyCar = Assembly.Load(car.Split(',')[1]);
            Type typePeople = assemblyPeople.GetType(people.Split(',')[0]);
            Type typeCar = assemblyPeople.GetType(car.Split(',')[0]);
            IPeople ipeople = (IPeople)Activator.CreateInstance(typePeople);
            ICar icar = (ICar)Activator.CreateInstance(typeCar);
            ipeople.Run(icar);
            Console.Read();
            #endregion
        }
    }

Program.cs

上面代碼中，我們使用反射+配置文件的方式，將對象創建的控制權轉移到了配置文件，這就是所謂的控制反轉。

分析：控制反轉是將對象創建的控制權交給了第三方，可以是IoC容器，它就相當於簡單工廠。我們要什麼對象，工廠就給我們什麼對象，這樣依賴關係就變了，它們（人和車）都依賴於IoC容器，通過IoC容器建立它們之間的依賴關係。（依賴對象不再直接通過new來獲取）

運行結果如下：

五、依賴註入

上面說到的控制反轉，我們瞭解到是將控制權轉移，這是我們的目的。配置文件+反射是一種實現，而依賴註入則提供的是一種思想，或者說是實現IoC的手段。

依賴註入是將對象的創建和綁定轉移到被依賴對象的外部來實現，一般使用哪些方法來實現呢？

方法一：構造函數註入

    class ChinesePeopleConstructor
    {
        private readonly ICar _car;

        //依賴註入：構造函數註入
        public ChinesePeopleConstructor(ICar car)
        {
            _car = car;
        }

        public void Run()
        {
            Console.WriteLine($"今天開{_car.Show()}上班");
        }
    }

ChinesePeopleConstructor.cs

    class Program
    {
        static void Main(string[] args)
        {
            #region 依賴註入：構造函數註入
            ICar bmw = new BMW();
            ChinesePeopleConstructor people = new ChinesePeopleConstructor(bmw);
            people.Run();
            Console.Read();
            #endregion
        }
    }

Program.cs

方法二：屬性註入

    class ChinesePeopleProperty
    {
        //依賴註入：屬性註入
        public ICar Car { get; set; }

        public void Run()
        {
            Console.WriteLine($"今天開{Car.Show()}上班");
        }
    }

ChinesePeopleProperty.cs

    class Program
    {
        static void Main(string[] args)
        {
            #region 依賴註入：屬性註入
            ICar bmw = new BMW();
            ChinesePeopleProperty people = new ChinesePeopleProperty
            {
                Car = bmw
            };
            people.Run();
            Console.Read();
            #endregion
        }
    }

Program.cs

方法三：介面註入

    interface IDependent
    {
        void SetDependent(ICar icar);
    }

IDependent.cs

    class ChinesePeopleInterface : IDependent
    {
        private ICar _car;

        //依賴註入：介面註入
        public void SetDependent(ICar car)
        {
            _car = car;
        }

        public void Run()
        {
            Console.WriteLine($"今天開{_car.Show()}上班");
        }
    }

ChinesePeopleInterface.cs

    class Program
    {
        static void Main(string[] args)
        {
            #region 依賴註入：介面註入
            ICar bmw = new BMW();
            ChinesePeopleInterface people = new ChinesePeopleInterface();
            people.SetDependent(bmw);
            people.Run();
            Console.Read();
            #endregion
        }
    }

Program.cs

六、IoC容器

IoC容器是一個DI框架，主要功能有一下幾點：

A.動態創建、註入依賴對象；

B.管理對象生命周期；

C.映射依賴關係；

常見的IoC容器：Spring.NET，Castle Windsor， Ninject，Autofac，Unity。。。

6.1、Unity容器使用

在上一篇《C# AOP學習筆記》的【使用EntLib\PIAB Unity實現AOP（帶配置）】中，已經使用Unity容器實現了IoC，讓我們再來看看配置文件：

假如只需要IoC不需要AOP，container是這樣子的：

<configuration>
  <configSections>
    <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Unity.Configuration"/>
  </configSections>
  <unity>
    <sectionExtension type="Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension, Unity.Interception.Configuration"/>
    <containers>
      <container name="IoCContainer">
        <!--註冊匹配規則：前面是完整類型名稱，後面是所在的dll名稱。-->
        <register type="LinkTo.Test.ConsoleAop.UnityConfigAOP.IUserProcessor,LinkTo.Test.ConsoleAop" mapTo="LinkTo.Test.ConsoleAop.UnityConfigAOP.UserProcessor,LinkTo.Test.ConsoleAop"></register>
      </container>
    </containers>
  </unity>
</configuration>