C# IoC學習筆記

時間  2020-03-29
標籤 c# ioc 學習 筆記 欄目 C# 简体版
原文   原文鏈接

    1、引言

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

    先初步瞭解幾個概念：設計模式

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

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

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

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

    IoC容器：依賴注入的框架，用來映射依賴，管理對象的建立和生存週期。函數

    2、依賴

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

    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；atom

    客戶端依賴對象BMW；

    ChinesePeople依賴對象BMW；

   3、依賴倒置原則

    過些日子來了新需求，中國人不只要開寶馬去上班，還要開奔馳去上班，若是按照上面直接依賴關係的方式去作，咱們就須要修改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類。想一下，這樣是否是挺好的，咱們能夠得出：上層再也不依賴細節，相比面向實現，面向接口較好，由於抽象相比細節要更穩定。

    4、控制反轉

    上面示例中，咱們實現了具體的人和具體的汽車的隔離，具體人只和汽車的接口有關。可是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來獲取）

    運行結果以下：

    5、依賴注入

    上面說到的控制反轉，咱們瞭解到是將控制權轉移，這是咱們的目的。配置文件+反射是一種實現，而依賴注入則提供的是一種思想，或者說是實現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

    6、IoC容器

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

    A.動態建立、注入依賴對象；

    B.管理對象生命週期；

    C.映射依賴關係；

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

    6.一、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>
View Code

    從IoC的註冊匹配規則能夠看出，前面是完整類型名稱，後面是所在的dll。這個就比較厲害了，假如一個系統有擴展的功能或者個性要求，只需配置使用新的dll便可，原有系統不須要改代碼。這樣，除了很好地符合了"開閉原則"外，對於構建一個可配置可擴展的系統，是一個很是厲害的利器。 

 

    參考自：

    http://www.javashuo.com/article/p-bverypbb-gz.html

    推薦博文：

    基於接口設計三層架構

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程