Spring.NET教程（一）——控制反轉(基礎篇)(轉)

              控制反轉（Inversion of Control，英文縮寫爲IoC）。我個人認爲控制反轉的意思是依賴對象(控制權)發生轉變，由最初的類本身來管理依賴對象轉變爲IoC框架來管理這些對象，使得依賴 脫離類本身的控制，從而實現鬆耦合。

              我們先來看一段代碼

namespace Dao
{
    public interface IPersonDao
    {
        void Save();
    }
}
namespace Dao
{
    public class PersonDao : IPersonDao
    {
        public void Save()
        {
            Console.WriteLine("保存　Person");
        }
    }
}
namespace SpringNetIoC
{
    class Program
    {
        static void Main(string[] args)
        {
            //　一般方法
            NormalMethod();
　　　　　　Console.ReadLine();
        }
        private static void NormalMethod()
        {
            IPersonDao dao = new PersonDao();
            dao.Save();
            Console.WriteLine("我是一般方法");
        }
    }
}

        Program必然需要知道IPersonDao接口和PersonDao類。

        爲了不暴露具體實現，我可以運用設計模式中的抽象工廠模式（Abstract Factory）來解決。

namespace DaoFactory
{
    public static class DataAccess
    {
        public static IPersonDao CreatePersonDao()
        {
            return new PersonDao();
        }
    }
}
namespace SpringNetIoC
{
    class Program
    {
        static void Main(string[] args)
        {
            //　一般方法
            //NormalMethod();
            //　工廠方法
            FactoryMethod();
            Console.ReadLine();
        }
        private static void NormalMethod()
        {
            IPersonDao dao = newPersonDao();
            dao.Save();
            Console.WriteLine("我是一般方法");
        }
        private static void FactoryMethod()
        {
            IPersonDao dao = DataAccess.CreatePersonDao();
            dao.Save();
            Console.WriteLine("我是工廠方法");
        }
    }
}

        這時，Program只需要知道IPersonDao接口和工廠，而不需要知道PersonDao類。

        然後我們試圖想象，要是有這樣的工廠框架幫我們管理依賴的對象就好了，於是控制反轉出來了。

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <sectionGroup name="spring">
      <section name="context" type="Spring.Context.Support.ContextHandler,　Spring.Core"/>
      <section name="objects" type="Spring.Context.Support.DefaultSectionHandler,　Spring.Core"/>
    </sectionGroup>
  </configSections>
  <spring>
    <context>
      <resource uri="config://spring/objects"/>
    </context>
    <objects xmlns="http://www.springframework.net">
      <description>一個簡單的控制反轉例子</description>
      <object id="PersonDao" type="Dao.PersonDao,　Dao"/>
    </objects>
  </spring>
  <startup> 
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
  </startup>
</configuration>

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Dao;
using DaoFactory;
using Spring.Context;
using Spring.Context.Support;

namespace SpringNetIoC
{
    class Program
    {
        static void Main(string[] args)
        {
            //　一般方法
            //NormalMethod();
            //　工廠方法
            //FactoryMethod();　　
            //　IoC方法"
            IoCMethod();
　　　　　　Console.ReadLine();
        }
        private static void NormalMethod()
        {
            IPersonDao dao = new PersonDao();
            dao.Save();
            Console.WriteLine("我是一般方法");
        }
        private static void FactoryMethod()
        {
            IPersonDao dao = DataAccess.CreatePersonDao();
            dao.Save();
            Console.WriteLine("我是工廠方法");
        }
        private static void IoCMethod()
        {
            IApplicationContext ctx = ContextRegistry.GetContext();
            //IPersonDao dao = ctx.GetObject("PersonDao") as IPersonDao;
            IPersonDao dao = (IPersonDao)ctx.GetObject("PersonDao");
            if (dao != null)
            {
                dao.Save();
                Console.WriteLine("我是IoC方法");
            }
        }
    }
}

        一個簡單的控制反轉程序例子就實現了。

        這樣從一定程度上解決了Program與PersonDao耦合的問題，但是實際上並沒有完全解決耦合，只是把耦合放到了XML 文件中，通過一個容器在需要的時候把這個依賴關係形成，即把需要的接口實現注入到需要它的類中。我個人認爲可以把IoC模式看做是工廠模式的昇華，可以把IoC看作是一個大工廠，只不過這個大工廠裏要生成的對象都是在XML文件中給出定義的。