ITKeyword,专注技术干货聚合推荐

注册 | 登录

Spring.NET学习笔记1——控制反转(基础篇)

hliq5399 分享于 2011-03-26

推荐:Spring.NET学习笔记3——实现一个简易的IoC框架(练习篇)

讲了这么多理论,我们来手动实现一个简易的IoC框架的,这样可以加深IoC的理论知识。   一、思路 在我们使用Spring.NET框架的时候,首先需要实例化Spring.NET容

2020腾讯云“6.18”活动开始了!!!(巨大优惠重现!4核8G,5M带宽 1999元/3年),
地址https://cloud.tencent.com/act/cps/redirect?redirect=1059

2020阿里云最低价产品入口,含代金券(新老用户有优惠),
地址https://www.aliyun.com/minisite/goods

在学习 Spring.NET这个控制反转(IoC)和面向切面(AOP)的容器 框架之前,我们先来看一下什么是控制反转(IoC)。

  控制反转(Inversion of Control,英文缩写为IoC),也叫依赖注入(Dependency Injection)。我个人认为控制反转的意思是依赖对象发生改变,由最初的类本身来管理依赖对象改变为IoC框架来管理这些对象,使得依赖脱离类本身的控制,从而实现松耦合。

我们先来看一段代码

  1. namespace Dao
  2. {
  3.     public interface IPersonDao
  4.     {
  5.         void Save();
  6.     }
  7.     public class PersonDao : IPersonDao
  8.     {
  9.         public void Save()
  10.         {
  11.             Console.WriteLine("保存 Person");
  12.         }
  13.     }
  14. }
  15. namespace SpringNetIoC
  16. {
  17.     class Program
  18.     {
  19.         private static void NormalMethod()
  20.         {
  21.             IPersonDao dao = new PersonDao();
  22.             dao.Save();
  23.             Console.WriteLine("我是一般方法");
  24.         }
  25.     }
  26. }
复制代码 Program必然需要知道IPersonDao 接口和PersonDao类。为了不暴露具体实现,我可以运用 设计模式中的抽象工厂模式(Abstract Factory)来解决。
  1. namespace DaoFactory
  2. {
  3.     public static class DataAccess
  4.     {
  5.         public static IPersonDao CreatePersonDao()
  6.         {
  7.             return new PersonDao();
  8.         }
  9.     }
  10. }
复制代码 FactoryMethod
  1. namespace SpringNetIoC
  2. {
  3.     class Program
  4.     {        private static void FactoryMethod()
  5.         {
  6.             IPersonDao dao = DataAccess.CreatePersonDao();
  7.             dao.Save();
  8.             Console.WriteLine("我是工厂方法");
  9.         }
  10.     }
  11. }
复制代码 这时,Program只需要知道IPersonDao接口和工厂,而不需要知道PersonDao类。然后我们试图想象,要是有这样的工厂框架帮我们管理依赖的对象就好了,于是控制反转出来了。 App.config
  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3.   <configSections>
  4.     <sectionGroup name="spring">
  5.       <section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core" />
  6.       <section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core" />
  7.     </sectionGroup>
  8.   </configSections>
  9.   <spring>
  10.     <context>
  11.       <resource uri="config://spring/objects" />
  12.     </context>
  13.     <objects xmlns="http://www.springframework.net">
  14.       <description>一个简单的控制反转例子</description>
  15.       <object id="PersonDao" type="Dao.PersonDao, Dao" />
  16.     </objects>
  17.   </spring>
  18. </configuration>
复制代码 Program
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using Dao;
  6. using DaoFactory;
  7. using Spring.Context;
  8. using Spring.Context.Support;
  9. namespace SpringNetIoC
  10. {
  11.     class Program
  12.     {
  13.         static void Main(string[] args)
  14.         {
  15.             //NormalMethod();  // 一般方法
  16.             //FactoryMethod();  // 工厂方法
  17.             IoCMethod();  // IoC方法"
  18.             Console.ReadLine();
  19.         }
  20.         private static void NormalMethod()
  21.         {
  22.             IPersonDao dao = new PersonDao();
  23.             dao.Save();
  24.             Console.WriteLine("我是一般方法");
  25.         }
  26.         private static void FactoryMethod()
  27.         {
  28.             IPersonDao dao = DataAccess.CreatePersonDao();
  29.             dao.Save();
  30.             Console.WriteLine("我是工厂方法");
  31.         }
  32.         private static void IoCMethod()
  33.         {
  34.             IApplicationContext ctx = ContextRegistry.GetContext();
  35.             IPersonDao dao = ctx.GetObject("PersonDao") as IPersonDao;
  36.             if (dao != null)
  37.             {
  38.                 dao.Save();
  39.                 Console.WriteLine("我是IoC方法");
  40.             }
  41.         }
  42.     }
  43. }
复制代码 一个简单的控制反转程序例子就实现了。

这样从一定程度上解决了Program与PersonDao耦合的问题,但是实际上并没有完全解决耦合,只是把耦合放到了XML 文件中,通过一个容器在需要的时候把这个依赖关系形成,即把需要的接口实现注入到需要它的类中。我个人认为可以把IoC模式看做是工厂模式的升华,可以把 IoC看作是一个大工厂,只不过这个大工厂里要生成的对象都是在XML文件中给出定义的。

 

在学习 Spring.NET这个控制反转(IoC)和面向切面(AOP)的容器 框架之前,我们先来看一下什么是控制反转(IoC)。   控制反转(Inversion of Control,英文缩写为IoC),也叫依赖注入(Dependency

相关阅读排行


相关内容推荐

最新文章

×

×

请激活账号

为了能正常使用评论、编辑功能及以后陆续为用户提供的其他产品,请激活账号。

您的注册邮箱: 修改

重新发送激活邮件 进入我的邮箱

如果您没有收到激活邮件,请注意检查垃圾箱。