【转】懂得依赖注入（IOC）和学习Unity - 设计模式当前位置:& &&&【转】懂得依赖注入（IOC）和学习Unity【转】懂得依赖注入（IOC）和学习Unity&&网友分享于：&&浏览：0次【转】理解依赖注入（IOC）和学习UnityIOC:英文全称：Inversion of Control，中文名称：控制反转，它还有个名字叫依赖注入（Dependency Injection）。作用：将各层的对象以松耦合的方式组织在一起，解耦，各层对象的调用完全面向接口。当系统重构的时候，代码的改写量将大大减少。理解依赖注入：& & 当一个类的实例需要另一个类的实例协助时，在传统的程序设计过程中，通常有调用者来创建被调用者的实例。然而采用依赖注入的方式，创建被调用者的工作不再由调用者来完成，因此叫控制反转，创建被调用者的实例的工作由IOC容器来完成，然后注入调用者，因此也称为依赖注入。举个有意思的例子（来源于互联网）
假如我们要设计一个Girl和一个Boy类，其中Girl有Kiss方法，即Girl想要Kiss一个Boy，首先问题是Girl如何认识Boy？
& & 在我们中国常见的MM认识GG的方式有以下几种：
& & A 青梅竹马 & &B 亲友介绍 & C 父母包办
& & 哪一种是最好的？
1.青梅竹马：很久很久以前，有个有钱的地主家的一闺女叫Lily，她老爸把她许配给县太爷的儿子Jimmy，属于指腹为婚，Lily非常喜欢kiss,但是只能kiss Jimmy
public&class&Lily{&&
&&&&&&&&public&Jimmy&&&&
&&&&&&&&public&Girl()&&
&&&&&&&&{&&
&&&&&&&&&&&&jimmy=new&Jimmy();&&
&&&&&&&&}&&
&&&&&&&&public&void&Kiss()&&
&&&&&&&&{&&
&&&&&&&&&&&&jimmy.Kiss();&&
&&&&&&&&}&&
&&&&public&class&Jimmy&&
&&&&&&&&public&void&Kiss()&&
&&&&&&&&{&&
&&&&&&&&&&&&Console.WriteLine("kissing");&&
&&&&&&&&}&&
这样导致Lily对Jimmy的依赖性非常强，紧耦合。
2.亲友介绍：经常Kiss同一个人令Lily有些厌恶了，她想尝试新人，于是与Jimmy分手了，通过亲朋好友（中间人）来介绍
public&class&Lily{&&
&&&&&&&&public&Boy&&&&
&&&&&&&&public&Girl()&&
&&&&&&&&{&&
&&&&&&&&&&&&boy=BoyFactory.createBoy();&&
&&&&&&&&}&&
&&&&&&&&public&void&Kiss()&&
&&&&&&&&{&&
&&&&&&&&&&&&boy.Kiss();&&
&&&&&&&&}&&
亲友介绍，固然是好。如果不满意，尽管另外换一个好了。但是，亲友BoyFactory经常是以Singleton的形式出现，不然就是，存在于Globals，无处不在，无处不能。实在是太繁琐了一点，不够灵活。我为什么一定要这个亲友掺和进来呢？为什么一定要付给她介绍费呢？万一最好的朋友爱上了我的男朋友呢？
3.父母包办：一切交给父母，自己不用非吹灰之力，Lily在家只Kiss
public&class&Lily{&&
&&&&&&&&public&Boy&&&&
&&&&&&&&public&Girl(Boy&boy)&&
&&&&&&&&{&&
&&&&&&&&&&&&this.boy=&&
&&&&&&&&}&&
&&&&&&&&public&void&Kiss()&&
&&&&&&&&{&&
&&&&&&&&&&&&this.boy.Kiss();&&
&&&&&&&&}&&
Well，这是对Girl最好的方法，只要想办法贿赂了Girl的父母，并把Boy交给他。那么我们就可以轻松的和Girl来Kiss了。看来几千年传统的父母之命还真是有用哦。至少Boy和Girl不用自己瞎忙乎了。这就是IOC，将对象的创建和获取提取到外部。由外部容器提供需要的组件。
在设计模式中我们应该还知道依赖倒转原则，应是面向接口编程而不是面向功能实现，好处是：多实现可以任意切换，我们的Boy应该是实现Kissable接口。这样一旦Girl不想kiss可恶的Boy的话，还可以kiss可爱的kitten和慈祥的grandmother
好在.net中微软有一个轻量级的IoC框架Unity，支持构造器注入，属性注入，方法注入如下图所示
具体使用方法如下图所示
using&Microsoft.Practices.U&&
namespace&ConsoleApplication9&&
&&&&class&Program&&
&&&&&&&&static&void&Main(string[]&args)&&
&&&&&&&&{&&
&&&&&&&&&&&&
&&&&&&&&&&&&IUnityContainer&container=new&UnityContainer();&&
&&&&&&&&&&&&
&&&&&&&&&&&&container.RegisterType&IKiss,&Boy&();&&
&&&&&&&&&&&&
&&&&&&&&&&&&var&boy&=&container.Resolve&IKiss&();&&
&&&&&&&&&&&&&
&&&&&&&&&&&&Lily&lily&=&new&Lily(boy);&&
&&&&&&&&&&&&lily.kiss();&&
&&&&&&&&}&&
&&&&public&interface&IKiss&&
&&&&&&&&void&kiss();&&
&&&&public&class&Lily:IKiss&&
&&&&&&&&public&IKiss&&&&
&&&&&&&&public&Lily(IKiss&boy)&&
&&&&&&&&{&&
&&&&&&&&&&&&this.boy=&&
&&&&&&&&}&&
&&&&&&&&public&void&kiss()&&
&&&&&&&&{&&
&&&&&&&&&&&&boy.kiss();&&
&&&&&&&&&&&&Console.WriteLine("lily&kissing");&&
&&&&&&&&}&&
&&&&public&class&Boy&:&IKiss&&
&&&&&&&&public&void&kiss()&&
&&&&&&&&{&&
&&&&&&&&&&&&Console.WriteLine("boy&kissing");&&
&&&&&&&&}&&
如果采用配置文件注册的话
配置的后台代码：
UnityConfigurationSection&configuration&=&ConfigurationManager.GetSection(UnityConfigurationSection.SectionName)&&
&&&&&&&&&&&&as&UnityConfigurationS&&
configuration.Configure(container,&"defaultContainer");&&
可以通过方法ResolveAll来得到所有注册对象的实例：var&Instances =&container.Resolve&IKiss&();Martin Fowler在那篇著名的文章《Inversion of Control Containers and the Dependency Injection pattern》中将具体依赖注入划分为三种形式，即构造器注入、属性（设置）注入和接口注入,习惯将其划分为一种（类型）匹配和三种注入：
类型匹配（Type Matching）：虽然我们通过接口（或者抽象类）来进行服务调用，但是服务本身还是实现在某个具体的服务类型中，这就需要某个类型注册机制来解决服务接口和服务类型之间的匹配关系；
构造器注入（Constructor Injection）：IoC容器会智能地选择选择和调用适合的构造函数以创建依赖的对象。如果被选择的构造函数具有相应的参数，IoC容器在调用构造函数之前解析注册的依赖关系并自行获得相应参数对象；
属性注入（Property Injection）：如果需要使用到被依赖对象的某个属性，在被依赖对象被创建之后，IoC容器会自动初始化该属性；
方法注入（Method Injection）：如果被依赖对象需要调用某个方法进行相应的初始化，在该对象创建之后，IoC容器会自动调用该方法。
我们创建一个控制台程序，定义如下几个接口（IA、IB、IC和ID）和它们各自的实现类（A、B、C、D）。在类型A中定义了3个属性B、C和D，其类型分别为接口IB、IC和ID。其中属性B在构在函数中被初始化，以为着它会以构造器注入的方式被初始化；属性C上应用了DependencyAttribute特性，意味着这是一个需要以属性注入方式被初始化的依赖属性；属性D则通过方法Initialize初始化，该方法上应用了特性InjectionMethodAttribute，意味着这是一个注入方法在A对象被IoC容器创建的时候会被自动调用。
public&interface&IA&{&}&&
&&&&public&interface&IB&{&}&&
&&&&public&interface&IC&{&}&&
&&&&public&interface&ID&{&}&&
&&&&public&class&A&:&IA&&
&&&&&&&&public&IB&B&{&&&}&&
&&&&&&&&[Dependency]&&
&&&&&&&&public&IC&C&{&&&}&&
&&&&&&&&public&ID&D&{&&&}&&
&&&&&&&&public&A(IB&b)&&
&&&&&&&&{&&
&&&&&&&&&&&&this.B&=&b;&&
&&&&&&&&}&&
&&&&&&&&[InjectionMethod]&&
&&&&&&&&public&void&Initalize(ID&d)&&
&&&&&&&&{&&
&&&&&&&&&&&&this.D&=&d;&&
&&&&&&&&}&&
&&&&public&class&B&:&IB&{&}&&
&&&&public&class&C&:&IC&{&}&&
&&&&public&class&D&:&ID&{&}&&
然后我们为该应用添加一个配置文件，并定义如下一段关于Unity的配置。这段配置定义了一个名称为defaultContainer的Unity容器，并在其中完成了上面定义的接口和对应实现类之间映射的类型匹配。
最后在Main方法中创建一个代表IoC容器的UnityContainer对象，并加载配置信息对其进行初始化。然后调用它的泛型的Resolve方法创建一个实现了泛型接口IA的对象。最后将返回对象转变成类型A，并检验其B、C和D属性是否是空
class&Program&&
&&&&&&&&static&void&Main(string[]&args)&&
&&&&&&&&{&&
&&&&&&&&&&&&UnityContainer&container&=&new&UnityContainer();&&
&&&&&&&&&&&&UnityConfigurationSection&configuration&=&ConfigurationManager.GetSection(UnityConfigurationSection.SectionName)&as&UnityConfigurationS&&
&&&&&&&&&&&&configuration.Configure(container,&"defaultContainer");&&
&&&&&&&&&&&&A&a&=&container.Resolve&IA&()&as&A;&&
&&&&&&&&&&&&if&(null!=a)&&
&&&&&&&&&&&&{&&
&&&&&&&&&&&&&&&&Console.WriteLine("a.B==null?{0}",a.B==null?"Yes":"No");&&
&&&&&&&&&&&&&&&&Console.WriteLine("a.C==null?{0}",&a.C&==&null&?&"Yes"&:&"No");&&
&&&&&&&&&&&&&&&&Console.WriteLine("a.D==null?{0}",&a.D&==&null&?&"Yes"&:&"No");&&
&&&&&&&&&&&&}&&
&&&&&&&&}&&
从如下给出的执行结果我们可以得到这样的结论：通过Resolve&IA&方法返回的是一个类型为A的对象，该对象的三个属性被进行了有效的初始化。这个简单的程序分别体现了接口注入（通过相应的接口根据配置解析出相应的实现类型）、构造器注入（属性B）、属性注入（属性C）和方法注入（属性D）
a.B == null ? No
a.C == null ? No
a.D == null ? No
12345678910
12345678910
12345678910 上一篇：下一篇：文章评论相关解决方案 1234567891011 Copyright & &&版权所有5750人阅读
Asp.Net（24）
& & & &Unity是Unity是微软patterns& practices组用C#实现的轻量级，可扩展的依赖注入容器，它为方便开发者建立松散耦合的应用程序，
有以下优点：
& & & & 1.简化了对象的创建，特别是针对分层对象结构和依赖关系；
　　 2.需求的抽象，允许开发人员在运行时或配置文件中指定依赖关系，简化横切关注点的管理；
　　 3.推迟为容器配置组件的时机，增加了灵活性；
　　 4.服务定位能力，这使客户能够存储或缓存容器；
& & & & 5.实例和类型拦截
目前最新的版本为 unity 3.0 for .net 3.5 preview
&以下程序用的是2.1版本
下面开始Unity之旅
&(一) 我的第一个Unity Demo
新建一个控制台应用程序,引用Microsoft.Practices.Unity.dll文件；&
新建一个鸟类的接口,定义一个鸟叫的方法;
/// &summary&
/// 鸟类接口
/// &/summary&
public interface IBird
/// &summary&
/// &/summary&
void Say( );
对这个接口进行实现:
/// &summary&
/// &/summary&
public class Swallow : IBird
public void Say( )
Console.WriteLine(&燕子在叫...&);
在Mian方法中通过Unity实现IOC反转控制;
static void Main( string[] args )
//实例化一个控制器
IUnityContainer unityContainer = new UnityContainer();
//实现注入
unityContainer.RegisterType&IBird, Swallow&();
IBird bird = unityContainer.Resolve&IBird&();
bird.Say();
Console.Read();
这个小实例已经实现了简单的IOC控制反转.
当一个接口有两个实现怎么办呢?是不是在加一个类似于下边的代码就行了呢? 下面试一下.
unityContainer.RegisterType&IBird, Swallow&();我们在原有的程序中加一个Sparrow类,实现IBird接口:
public class Sparrow : IBird
public void Say()
Console.WriteLine(&麻雀在叫....&);
Main方法代码:
//实例化一个控制器
IUnityContainer unityContainer = new UnityContainer();
//实现注入
unityContainer.RegisterType&IBird, Swallow&();
unityContainer.RegisterType&IBird, Sparrow&();
IBird bird = unityContainer.Resolve&IBird&();
bird.Say();
Console.Read();
运行一下,结果:
嗯?这是什么情况,为什么是麻雀在叫..而不是燕子叫呢? 原来
当一个接口有多个实现,而且没有用别名区分时,就会选择最后一个注入的实现;
下边给每个注入都加上别名:
//实例化一个控制器
IUnityContainer unityContainer = new UnityContainer();
//实现注入,用别名区分实现
unityContainer.RegisterType&IBird, Swallow&(&Swallow&);
unityContainer.RegisterType&IBird, Sparrow&(&Sparrow&);
IBird swallow = unityContainer.Resolve&IBird&(&Swallow&);
IBird sparrow = unityContainer.Resolve&IBird&(&Sparrow&);
swallow.Say();
sparrow.Say();
Console.Read();
这才是我们想要的结果,哈哈.....
当一个接口有多个实现时,需要通过别名区分。
(二) Unity的构造函数注入
新建 一个IBirdHome 接口,并对接口进行实现:
/// &summary&
/// 小鸟的家
/// &/summary&
public interface IBirdHome
IBird Swallow { }
/// &summary&
/// 小鸟的家
/// &/summary&
public class BirdHome : IBirdHome
public IBird Swallow { }
public BirdHome(IBird bird)
this.Swallow =
main方法如下:
//实例化一个控制器
IUnityContainer unityContainer = new UnityContainer();
//实现注入
unityContainer.RegisterType&IBird, Swallow&();
unityContainer.RegisterType&IBirdHome, BirdHome&();
IBirdHome birdHome = unityContainer.Resolve&IBirdHome&();
birdHome.Swallow.Say();
Console.Read();
我们只是通过Unity得到了一个IBirdHome实现,但并没有对&IBird Swallow { }&进行实例化,但结果已经运行出来,并没有报错.
原来这些工作Unity已帮我们做了,我们可以偷个懒了.嘿嘿.......
(三)属性注入
把BirdHome类的中构造函数去掉,在属性上加上[Dependency]特性
/// &summary&
/// 小鸟的家
/// &/summary&
public class BirdHome : IBirdHome
/// &summary&
/// 属性注入
/// &/summary&
[Dependency]
public IBird Swallow { }
运行结果与上结果一样,亲,不信,试试!
(四) 初使化器注入(自已起的名字)
初使化器注入与构造函数注入相似,但不用写到构造函数里边,而是在初使化方法上加上[InjectionMethod]特性
/// &summary&
& & & & /// 初始化器注入
& & & & /// &/summary&
& & & & /// &param name=&bird&&&/param&
& & & &[InjectionMethod]
& & & & public void Initialize(IBird bird)
& & & & & & this.Swallow =
运行结果依然是:
欢迎大家前来拍砖........!
生命不息,编程不止!
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：228895次
积分：2573
积分：2573
排名：第10601名
原创：50篇
转载：21篇
评论：33条
(2)(1)(1)(1)(1)(3)(5)(8)(5)(1)(1)(3)(1)(1)(1)(1)(4)(1)(2)(1)(1)(3)(4)(6)(2)(2)(3)(2)(1)(3)自由、创新、研究、探索
Linux/Windows Mono/DotNet [ Open Source .NET Development/ 使用开源工具进行DotNet软件开发]锐意进取，志存高远.成就梦想，只争朝夕.从你开始，创新世界.【That I exist is a perpetual supprise which is life. Focus on eCommerce】
在码农的世界里，为了应付时常变更的客户需求，增加的架构的客扩展性，减少工作量。IOC诞生了，它是一种可以实现依赖注入和控制对象生命周期的容器。最为一个有节操、有追求的码农来说，掌握几种IOC以来注入的技术是必不可少的。帅的人至少要会两种以上。在.net世界里，如今常用的注入容器有Unity、Autoface、Ninject当然Spring.net也算。在没有IOC之前，伟大的码农们，大多数软件开发都使用DI手动完成构造函数、属性、方法的依赖，来实现解耦，通俗易懂的话就是完全的接口编程。
今天我们了解一下Unity，Unity是微软的一种用于C#实现的依赖注入容器，可通过Xml文件或代码来建立对象之间的关系在运行时直接调用容器，便可获取依赖产生的对象，建立耦合度较低的应用程序。Microsoft.Practices.Unity.dll和Microsoft.Practices.Unity.Configuration.dll这两个程序集是Unity里面的集成类库，用于Unity对象操作和配置的类库。
使用Unity的好处就是调用方法时将相应的controllerType传递给Unity容器，Unity容器便会自己完成对象创建的操作，并将对象返回给请求。再也不用考虑如何对象从哪里来的问题。Unity在管理生命周期时创建对象自带了Transient(瞬态)、Singleton（单例）两种方式，从字面上看，transient在用户每次请求容器中对象时，都会创建新的对象，完成相应后会自动销毁，而SingleTon它不会立即销毁会供多个应用请求提供相同的对象。你可以把这两种产生的对象，想象成request和application产生的对象，有点类似。下面结合.NetMvc4举个例子来看一下它的使用：
1、使用NUGET获取并安装Unity，如图：
安装完后在引用中可以看到Unity的两个重要的DLL程序集，并生成Bootstrap.cs引导文件， 下面我们可以开始我们的 编程了，这次使用xml配置Unity。
2、建立项目工程，如图：
顺序没排好，正确顺序如下：
（1）MvcIOCUnity MVC && 应用程序
（2）ImpLab &&&仓储的实现类
（3）RepositoryLab && 方法仓储接口
（4）ModelLab&&基础对象模型类
程序从下而上进行编码：
ModelLab&&基础对象模型类，中创建模型
&View Code
&View Code
RepositoryLab && 方法仓储接口
&View Code
&ImpLab &&&仓储的实现
&View Code
　MvcIOCUnity MVC && 应用程序
第一步配置Uinit
&Unity xml 配置
第二步在BootStrap中读写Xml配置生成容器，并在Global中注册，让网站启动时便将容器准备完毕。
&Bootstrap调用xml创建容器
&Global注册
第三步 创建UnityDependencyResolver
&DependencyResolver.SetResolver(new UnityDependencyResolver(container));这行代码用于解析装载为Mvc依赖关系提供了一个解析程序的接口。参数必须是个继承IDependencyResolver的对象。
&创建UnityDependencyResolver
第四步 通过DefaultControllerFactory工厂获取ContorllerType和请求上下文，使用IUnityContainer进行解析
&创建UnityControllerFactory
第五步 使用容器创建的对象
&创建FamilyController
第六步创建试图，收工
源代码奉上：/s/1i3L1kd3
阅读(...) 评论()
随笔 - 15080
评论 - 1097& 1.引言 高内聚，低耦合成为一个OO架构设计的一个参考标准。高内聚是一个模块或者一个类中成员跟这个模块或者类的关系尽量高，低耦合是不同模块或者不同类之间关系尽量简单。 拿咱国家举例来说，假如你是中国人。 高内聚：就是说你跟中国亲，关系好，国家会保护你。 低内聚：就是说你跟中国的关系不好，那还怎么混，改天就要批斗你，你就是个问题源。 低耦合：就是说你跟日本的关系非常正常，非常简单，这样的话，就不会被骂汉奸了。 高耦合：就是说你跟日本亲，活该被砸，被游街。 上面例子虚构的，不太贴切，但从中可以看出来高内聚和低耦合的处境是最好的。高内聚是对内部成员跟本身这个模块的关系的描述，低耦合是对成员跟外部模块之间关系的描述。对内对外也是一个相对范围，一个模块里面的小模块之间是耦合，对大模块是聚合，所以说耦合无处不在，我们都要低耦合，Untity就可以帮助我们。 2.Unity Unity是一个IoC容器，用来实现依赖注入（Dependency Injection，DI），减少耦合的，Unity出自于伟大的微软。对依赖注入和IoC模式可以查看之前一篇文章。unity组件网址：网址中有源码有文档有示例，大家可以下载。我是用的是2.1版本。 看看Unity能做些什么，列举部分如下： 1.Unity支持简单对象创建，特别是分层对象结构和依赖，以简化程序代码。其包含一个编译那些可能存在依赖于其他对象的对象实例机制。2.Unity支持必要的抽象，其允许开发者在运行时或配置去指定依赖关系同时可以简单的管理横切点（AOP）。3.Unity增加了推迟到容器组件配置的灵活性。其同样支持一个容器层次的结构。4.Unity拥有服务定位能力，对于一个程序在许多情况下重复使用组件来分离和集中功能是非常有用的。5.Unity允许客户端储存或缓存容器。对于在ASP.NET Web applications中开发者将容器持久化于ASP.NET中的session或application中特别有效。6.Unity拥有拦截能力，其允许开发者通过创建并执行handlers（在方法或属性被调用到达之前）来为已存在的组件增加一个函数，并再次为返回调用结果。7.Unity可以从标准配置系统中读取配置信息，例如：XML文件，同时使用配置文件来配置容器。8.Unity支持开发者实现自定义容器扩展，例如：你可以实现方法来允许额外的对象构造和容器特征，例如缓存。9.Unity允许架构师和开发者在现代化的程序中更简单的实现通用设计模式。 ..... 我们项目中什么时候要使用到Unity呢，如下情况： 1.所构建的系统依赖于健全的面向对象原则，但是大量不同的代码交织在一起而难以维护。2.构建的对象和类需要依赖其他对象或类。3.依赖于复杂的或需要抽象的对象。4.希望利用构造函数、方法或属性的调用注入优势。5.希望管理对象实例的生命周期。6.希望能够在运行时管理并改变依赖关系。7.希望在拦截方法或属性调用的时候生成一个策略链或管道处理容器来实现横切（AOP）任务。8.希望在Web Application中的回发操作时能够缓存或持久化依赖关系。 .............. 先看看Unity容器IUnityContainer 接口的定义： View Code
Code //Interface defining the behavior of the Unity dependency injection container.
public interface IUnityContainer : IDisposable
//The parent of this container.
IUnityContainer Parent { get; }
//Get a sequence of Microsoft.Practices.Unity.ContainerRegistration that describe
//the current state of the container.
IEnumerable&ContainerRegistration& Registrations { get; }
//Add an extension object to the container.
IUnityContainer AddExtension(UnityContainerExtension extension);
//Run an existing object through the container and perform injection on it.
object BuildUp(Type t, object existing, string name, params ResolverOverride[] resolverOverrides);
//Resolve access to a configuration interface exposed by an extension.
object Configure(Type configurationInterface);
//Create a child container.
IUnityContainer CreateChildContainer();
//Register an instance with the container.
IUnityContainer RegisterInstance(Type t, string name, object instance, LifetimeManager lifetime);
//Register a type mapping with the container, where the created instances will
//use the given Microsoft.Practices.Unity.LifetimeManager.
IUnityContainer RegisterType(Type from, Type to, string name, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers);
//Remove all installed extensions from this container.
IUnityContainer RemoveAllExtensions();
//Resolve an instance of the requested type with the given name from the container.
object Resolve(Type t, string name, params ResolverOverride[] resolverOverrides);
//Return instances of all registered types requested.
IEnumerable&object& ResolveAll(Type t, params ResolverOverride[] resolverOverrides);
//Run an existing object through the container, and clean it up.
void Teardown(object o);
IUnityContainer 中有几个方法经常会使用到，如：RegisterInstance，RegisterType，Resolve等等。
Unity为了方便操作，专门为IUnityContainer 提供了许多的扩展方法，部分方法声明如：
Code/// &summary&
/// 扩展方法 v2.0.50727
/// &/summary&
public static class UnityContainerExtensions
public static IUnityContainer AddNewExtension&TExtension&(this IUnityContainer container) where TExtension : UnityContainerE
public static T BuildUp&T&(this IUnityContainer container, T existing, params ResolverOverride[] resolverOverrides);
public static T BuildUp&T&(this IUnityContainer container, T existing, string name, params ResolverOverride[] resolverOverrides);
public static object BuildUp(this IUnityContainer container, Type t, object existing, params ResolverOverride[] resolverOverrides);
public static TConfigurator Configure&TConfigurator&(this IUnityContainer container) where TConfigurator : IUnityContainerExtensionC
public static bool IsRegistered&T&(this IUnityContainer container);
public static bool IsRegistered&T&(this IUnityContainer container, string nameToCheck);
public static bool IsRegistered(this IUnityContainer container, Type typeToCheck);
public static bool IsRegistered(this IUnityContainer container, Type typeToCheck, string nameToCheck);
public static IUnityContainer RegisterInstance&TInterface&(this IUnityContainer container, TInterface instance);
public static IUnityContainer RegisterInstance&TInterface&(this IUnityContainer container, string name, TInterface instance);
public static IUnityContainer RegisterInstance&TInterface&(this IUnityContainer container, TInterface instance, LifetimeManager lifetimeManager);
public static IUnityContainer RegisterInstance(this IUnityContainer container, Type t, object instance);
public static IUnityContainer RegisterInstance&TInterface&(this IUnityContainer container, string name, TInterface instance, LifetimeManager lifetimeManager);
public static IUnityContainer RegisterInstance(this IUnityContainer container, Type t, object instance, LifetimeManager lifetimeManager);
public static IUnityContainer RegisterInstance(this IUnityContainer container, Type t, string name, object instance);
public static IUnityContainer RegisterType&T&(this IUnityContainer container, params InjectionMember[] injectionMembers);
public static IUnityContainer RegisterType&TFrom, TTo&(this IUnityContainer container, params InjectionMember[] injectionMembers) where TTo : TF
public static IUnityContainer RegisterType&T&(this IUnityContainer container, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers);
public static IUnityContainer RegisterType&TFrom, TTo&(this IUnityContainer container, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers) where TTo : TF
public static IUnityContainer RegisterType&TFrom, TTo&(this IUnityContainer container, string name, params InjectionMember[] injectionMembers) where TTo : TF
public static IUnityContainer RegisterType&T&(this IUnityContainer container, string name, params InjectionMember[] injectionMembers);
public static IUnityContainer RegisterType(this IUnityContainer container, Type t, params InjectionMember[] injectionMembers);
public static IUnityContainer RegisterType&T&(this IUnityContainer container, string name, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers);
public static IUnityContainer RegisterType&TFrom, TTo&(this IUnityContainer container, string name, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers) where TTo : TF
public static IUnityContainer RegisterType(this IUnityContainer container, Type t, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers);
public static IUnityContainer RegisterType(this IUnityContainer container, Type t, string name, params InjectionMember[] injectionMembers);
public static IUnityContainer RegisterType(this IUnityContainer container, Type from, Type to, params InjectionMember[] injectionMembers);
public static IUnityContainer RegisterType(this IUnityContainer container, Type t, string name, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers);
public static IUnityContainer RegisterType(this IUnityContainer container, Type from, Type to, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers);
public static IUnityContainer RegisterType(this IUnityContainer container, Type from, Type to, string name, params InjectionMember[] injectionMembers);
public static T Resolve&T&(this IUnityContainer container, params ResolverOverride[] overrides);
public static T Resolve&T&(this IUnityContainer container, string name, params ResolverOverride[] overrides);
public static object Resolve(this IUnityContainer container, Type t, params ResolverOverride[] overrides);
public static IEnumerable&T& ResolveAll&T&(this IUnityContainer container, params ResolverOverride[] resolverOverrides);
public static IUnityContainer LoadConfiguration(this IUnityContainer container);
public static IUnityContainer LoadConfiguration(this IUnityContainer container, string containerName);
public static IUnityContainer LoadConfiguration(this IUnityContainer container, UnityConfigurationSection section);
public static IUnityContainer LoadConfiguration(this IUnityContainer container, UnityConfigurationSection section, string containerName);
下面来个简单的例子，现在项目中添加Microsoft.Practices.Unity.dll和Microsoft.Practices.Unity.Configuration.dll的引用，准备几个类，如下：
Code/// &summary&
/// 班级接口
/// &/summary&
public interface IClass
string ClassName { get; set; }
void ShowInfo();
/// &summary&
/// 计科班
/// &/summary&
public class CbClass : IClass
public string ClassName { get; set; }
public void ShowInfo()
Console.WriteLine("计科班：{0}", ClassName);
/// &summary&
/// 电商班
/// &/summary&
public class EcClass : IClass
public string ClassName { get; set; }
public void ShowInfo()
Console.WriteLine("电商班：{0}", ClassName);
用编程方式实现注入：
Codepublic static void ContainerCodeTest1()
IUnityContainer container = new UnityContainer();
//默认注册（无命名）,如果后面还有默认注册会覆盖前面的
container.RegisterType&IClass, CbClass&();
//命名注册
container.RegisterType&IClass, EcClass&("ec");
//解析默认对象
IClass cbClass = container.Resolve&IClass&();
cbClass.ShowInfo();
//指定命名解析对象
IClass ecClass = container.Resolve&IClass&("ec");
ecClass.ShowInfo();
//获取容器中所有IClass的注册的已命名对象
IEnumerable&IClass& classList = container.ResolveAll&IClass&();
foreach (var item in classList)
item.ShowInfo();
配置文件方式：
Code&?xml version="<span style="color: #8b" encoding="utf-8"?&
&configuration&
&configSections&
&section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration"/&
&/configSections&
&unity xmlns="/practices/2010/unity"&
&!--定义类型别名--&
&add alias="IClass" type="ConsoleApplication1.UnityDemo.IClass,ConsoleApplication1" /&
&add alias="CbClass" type="ConsoleApplication1.UnityDemo.CbClass,ConsoleApplication1" /&
&add alias="EcClass" type="ConsoleApplication1.UnityDemo.EcClass,ConsoleApplication1" /&
&/aliases&
&!--容器--&
&container name="FirstClass"&
&!--映射关系--&
&register type="IClass"
mapTo="CbClass"&&/register&
&register type="IClass" name="ec" mapTo="EcClass"&&/register&
&/container&
&/configuration&
Codepublic static void ContainerConfigurationTest1()
IUnityContainer container = new UnityContainer();
string configFile = "/UnityDemo/Constructor/Unity.config";
var fileMap = new ExeConfigurationFileMap { ExeConfigFilename = configFile };
//从config文件中读取配置信息
Configuration configuration =
ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
//获取指定名称的配置节
UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
//载入名称为FirstClass 的container节点
container.LoadConfiguration(section, "FirstClass");
//解析默认对象
IClass cbClass = container.Resolve&IClass&();
cbClass.ShowInfo();
//指定命名解析对象
IClass ecClass = container.Resolve&IClass&("ec");
ecClass.ShowInfo();
//获取容器中所有IClass的注册的已命名对象
IEnumerable&IClass& classList = container.ResolveAll&IClass&();
foreach (var item in classList)
item.ShowInfo();
效果跟代码方式一样
Unity使用方式基本分为三步：
声明容器IUnityContainer
Register注册类型
Resolve解析类型对象
看到IUnityContainer接口声明还是比较简单的，主要用到的方法也不多，另外提供了扩展方法，看起来代码挺多，都是一些方法重载，不要对Unity组建感到恐惧，我们只是简单的使用它，主要是使用IUnityContainer。
阅读(...) 评论()