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文件中给出定义的。

 

阅读更多
文章标签: 控制反转 Spring Ioc
个人分类: C# Spring.Net
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭