在过去几年中，依赖关系注入 (DI) 模式在 .NET 开发人员社区一直受到关注。长时间以来，优秀的博客作者们讨论着 DI 的优点。MSDN 杂志 针对这一主题发表了多篇文章。.NET 4.0 将发布某种类似 DI 的功能，并计划以后将其发展为完整的 DI 系统。 阅读有关 DI 的博客文章时，我注意到，这一主题有一个很小却很重要的倾向。作者们谈论的是如何在整个应用程序环境中使用 DI。但如何编写使用 DI 的库或框架呢？关注重点的变化，对模式的使用有何影响？这是几个月前我们研究 Enterprise Library 5.0 的体系结构时首先遇到的问题。 背景 Microsoft Enterprise Library (Entlib) 是 Microsoft 模式与实施方案组开发的著名版本。迄今为止，其下载次数已超过两百万。可以想到的单位 — 从金融机构、政府机关到餐厅和医疗设备制造商 — 都在使用它。顾名思义，Entlib 是一种库，可帮助开发人员处理许多企业开发人员都会面临的问题。如果您不熟悉 Entlib，请访问我们的网站 p&p 开发中心，以了解更多信息。 Entlib 在很大程度上由配置驱动。它的大部分代码专用于读取配置，然后基于配置组合对象图。Entlib 对象可能非常复杂。大多数块都包含大量可选功能。此外，还有许多用于支持检测等功能的底层基础结构，它们也需要进行关联。我们不希望用户仅仅为了使用 Entlib 而去手动创建检测提供程序、读取配置，等等，所以将对象的创建封装在了工厂对象和静态外层之后。 Entlib 版本 2 到版本 4 的核心是一个名为“ObjectBuilder”的小型框架。ObjectBuilder 的作者将 ObjectBuilder 描述为“一种用于构建依赖关系注入容器的框架”。Enterprise Library 只是使用 ObjectBuilder 的 p&p 项目之一；其他使用 ObjectBuilder 的 p&p 项目包括 Composite UI Application Block、Smart Client Software Factory 和 Web Client Software Factory。Entlib 特别注重说明的“框架”部分，将一个很大的自定义功能集构建至 ObjectBuilder。读取 Entlib 配置和组合对象图时，需要使用这些自定义功能。在很多情况下，也需要用它们来改进现有 ObjectBuilder 实现的性能。 缺点在于，需要不少时间才能对 ObjectBuilder 本身（设计极为抽象，再加上完全没有文档，ObjectBuilder 的复杂性绝非虚言）和 Entlib […]
View Details在前面几篇有关Unity学习的文章中，我对Unity的一些常用功能进行介绍，包括：Unity的基本知识、管理对象之间的关系、生命周期、依赖注入等，今天则是要介绍Unity的另外一个重要功能——拦截（Interception）。 以下是本文所要介绍的内容： 1、Unity与PIAB的关系。 2、使用Unity来接管PIAB的功能实现。 一、Unity与PIAB的关系 Unity中的Interception可以通过Unity的Container或独立的API（Intercept）来实现，这些具体的实现没有包含在Unity本身的类库中，而独立放在Unity.Interception这个类库中，想深入了解的朋友可以查看下这个类的具体源代码。今天介绍的则是Unity与企业库内置的PolicyInjection模块的使用。 在我看来，PolicyInjection就像是Unity.Interception模块的一个通用封装，在PIAB中包含了各种常用的MatchRules（匹配规则）与CallHandler（调用处理程序），其中各种CallHandler都是实现Unity.InterceptionExtension.ICallHandler，而ICallHandler其定义与Unity.InterceptionExtension.IInterceptionBehavior类似的。所以由于PIAB中已经内置好了各种常用的功能，我们只需按照我们的需求调用既可（可参看：内置Call Handler介绍和自定义Matching Rule），如果需要有特殊的逻辑也只需自己定义具体的CallHandler既可（可参看：建立自定义Call Handler实现用户操作日志记录），当然这些都是建立在PIAB的基础上的，如果你不想通过PIAB来实现AOP拦截处理的话，你就可以直接实现Unity中的IInterceptionBehavior来进行具体的业务处理，这个在后面的文章中会介绍到。 其实查看过PIAB模块源码的朋友就可以发现，其实PIAB本质上都是依赖于Unity.Interception模块，其本身没有具体的实现，其具体实现都包含在Unity.Interception.PolicyInjection下（包括MatchRules与CallHandler），有兴趣的朋友可以查看下。由于PIAB依赖于Unity.Interception，所以我们完全可以通过Unity来接管原有PIAB的所有功能（包括各种配置信息）。 二、使用Unity来接管PIAB的功能实现 在建立自定义Call Handler实现用户操作日志记录一文中我已经实现好了一个自定义的CallHandler（如不了解可以先查看下PIAB相关的文章），不过表示层的具体调用还是通过PIAB的PolicyInjection.Create来获取具体对象，而现在我就要通过Unity来接管原来PIAB的这些对象创建，这样极大程度的统一了对象创建与依赖管理。 我这边还是通过代码及配置2种方式来实现Unity接管PIAB的功能，首先是代码的形式，代码配置相对来说比较繁琐，见如下代码：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
private void Login1() { try { IUnityContainer container = new UnityContainer().AddNewExtension<Interception>(); container.Configure<Interception>() //为IStudentManage设置拦截器为TransparentProxyInterceptor .SetDefaultInterceptorFor<IStudentManage>(new TransparentProxyInterceptor()) .AddPolicy("UserLog") //增加MemberNameMatchingRule，使用InjectionConstructor初始化MemberNameMatchingRule的构造函数 .AddMatchingRule<MemberNameMatchingRule> (new InjectionConstructor("Login")) //增加CallHandler，使用InjectionConstructor来初始化CallHandler的构造函数 .AddCallHandler<UserLogCallHandler> ("UserLogCallHandler", new ContainerControlledLifetimeManager(), new InjectionConstructor("登录成功", "")); //注册对象关系 container.RegisterType<IStudentManage, StudentManage>(); IStudentManage studentBll = container.Resolve<IStudentManage>(); bool isAdmin2 = false; if (studentBll.Login(txtUid.Text.Trim(), txtPwd.Text.Trim(), out isAdmin2)) { if (string.IsNullOrEmpty(Request.QueryString["returnUrl"]) == false) { Response.Redirect(Request.QueryString["returnUrl"]); } else { Response.Redirect("~/Default.aspx"); } } else { ltMsg.Text = "用户名或密码不正确,请重试!"; } } catch (Exception ex) { throw; } } |
在底层不变的情况下，表示层如果想通过Unity来实现需要以上的代码配置。虽然配置较为繁琐，但是Unity很好的接管了PIAB的功能同时很大程度的解决了代码之间的耦合关系，其中有3个注意点： 1、创建Unity的container容器时需要增加Interception扩展：.AddNewExtension<Interception>(); 2、在增加策略是需要为需要拦截的接口增加拦截器：SetDefaultInterceptorFor<IStudentManage>(new TransparentProxyInterceptor()) 3、如果MatchRule或CallHandler有相应的构造函数需要通过InjectionConstructor类来初始化构造函数。 接下来是配置文件的代码，如下代码：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
<unity xmlns="http://schemas.microsoft.com/practices/2010/unity"> <!--新增配置节扩展，用于下面的<interception>配置节--> <sectionExtension type="Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension, Microsoft.Practices.Unity.Interception.Configuration" /> <alias alias="IStudentManage" type="EntLibStudy.IBLL.IStudentManage,EntLibStudy.IBLL"/> <alias alias="StudentManage" type="EntLibStudy.BLL.StudentManage,EntLibStudy.BLL"/> <container> <!--为容器增加Interception扩展，如不增加下面interception配置会报错--> <extension type="Interception"/> <interception> <!--增加一个名为UserLog的拦截策略，用于记录日志--> <policy name="UserLog"> <!--新增MemberNameMatchingRule匹配规则，同时需要同过配置初始化匹配规则构造函数 具体可查看Unity.InterceptionExtension.PolicyInjection.MatchRule下具体类--> <matchingRule name="Member Name Matching Rule" type="MemberNameMatchingRule"> <constructor> <param name="nameToMatch" value="Login"/> </constructor> </matchingRule> <!--增加调用处理程序，这边指定的是我自定义的UserLogCallHandler--> <!--同样也需要初始化构造函数--> <callHandler name="UserLogCallHandler" type="EntLibStudy.Helper.EntLibExtension.PolicyInjectionExtension.UserLogCallHandler, EntLibStudy.Helper, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"> <constructor> <param name="message" type="System.String" value="登录成功！"> </param> <param name="parameterName" type="System.String" value=" "> </param> </constructor> </callHandler> </policy> </interception> <!--注册对象关系，需要注意的是需要为这个注册增加TransparentProxyInterceptor的拦截器--> <register type="IStudentManage" mapTo="StudentManage"> <interceptor isDefaultForType="true" type="TransparentProxyInterceptor"/> </register> </container> </unity> |
读取配置程序代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
private void Login2() { IUnityContainer container = new UnityContainer() .LoadConfiguration("Log"); IStudentManage studentBll = container.Resolve<IStudentManage>(); bool isAdmin2 = false; if (studentBll.Login(txtUid.Text.Trim(), txtPwd.Text.Trim(), out isAdmin2)) { if (string.IsNullOrEmpty(Request.QueryString["returnUrl"]) == false) { Response.Redirect(Request.QueryString["returnUrl"]); } else { Response.Redirect("~/Default.aspx"); } } else { ltMsg.Text = "用户名或密码不正确,请重试!"; } } |
可以看到配置文件代码相对来说也不少，但是对于项目使用来说还是偏向于通过配置来解决代码的耦合问题，而且Unity的XSD提供了很好的智能提示，保证了书写配置文件效率及正确性，而且通过将这种具体的关联移到配置文件中也可以大大的减少程序代码的书写，程序代码只需要一句简单初始化+读取配置节既可完成。 配置方式实现的注意点和代码实现类似，我已经写在上面的配置文件中了，其效果和代码配置是一样的。 以上就是本文的所有内容了，仅仅介绍了如何通过Unity来接管PIAB的工作，我这边举的例子是依赖于我原先自己创建的CallHandler，内置的CallHandler配置也是类似的，这边就不再详细介绍了，想了解的朋友还是去查看Unity的官方文档。 有关Unity的拦截技术点可以查看官方文档：Unity Interception Techniques 源代码下载：点我下载 转自：http://www.cnblogs.com/kyo-yo/archive/2010/12/08/Learning-EntLib-Tenth-Decoupling-Your-System-Using-The-Unity-PART3-Unity-And-PIAB.html
View Details继续学习Unity，在前几篇中已经将Unity的使用方法做了一个还算详细的介绍了，主要是如何通过代码及配置文件来注册对象之间的关系、Unity内置所有的生命周期管理使用介绍，及Unity的Register和Resolve的一些高级应用。通过在PART1——为什么要使用Unity？的学习我们知道Unity可以帮我们简化并管理对象之间的关系（也就是前几篇所介绍的），而今天则要介绍Unity的另外一个重要功能——DI（依赖注入）。 本篇文章将主要介绍： 1、构造函数注入。 2、属性注入。 3、方法注入。 4、使用配置完成各种注入。 5、对已经创建对象进行注入。 一、构造函数注入 在有些时候，我们所编写的类中的构造函数都会包含对其他对象的引用，如下代码：
|
1 2 3 4 5 |
public Subject2(MyClass myClass1,MyClass myClass2) { myClass1.Name = "班级1"; myClass2.Name = "班级2"; } |
可以看到这个构造函数有2个参数，都依赖于MyClass类，如果一般情况下想要调用，我们总是需要实现构建好2个myclass对象，所以相对来说比较麻烦，而如果使用Unity来调用就会方便许多，如下代码：
|
1 |
container.Resolve<Subject2>(); |
仅仅一行既可，Unity容器会自动帮我们构建好所需的依赖对象实例。 当然这个只是简单的使用，在实际的情况下我们不会这么编写代码，我们不会直接引用对象，而是直接引用接口，这样可以解除代码的耦合性，如下代码：
|
1 2 3 4 |
public Subject2(IClass myClass1) { myClass1.Name = "班级1"; } |
这样Subject2类的构造函数仅仅依赖于IClass接口，并依赖于具体的实现类，这种情况下，如果想调用的话，需要实现注册好对象之间的关系，如下代码：
|
1 2 3 4 5 6 7 |
public static void ConstructorInjection() { //container.Resolve<Subject2>(); container.RegisterType<IClass, MyClass>(); container.Resolve<Subject2>(); } |
通过Unity容器对象的获取对象时候默认总是获取非命名默认注册对象，但是如果调用Subject2的构造函数参数我想指定具体的对象时怎么办？ 这时就需要使用Dependency这个特性类来解决了，在需要特殊指定的依赖关系的参数上加上Dependency特性，并为Dependency指定好参数name（此name参数表示注册对象关系时所指定的名称），代码如下：
|
1 2 3 4 5 |
public Subject2([Dependency("your")] IClass classInfo) { classInfo.Name = "班级1"; } |
调用代码：
|
1 2 3 |
container.RegisterType<IClass, MyClass>() .RegisterType<IClass, YourClass>("your"); container.Resolve<Subject2>(); |
可以看到，我对IClass注册了2个对象，而我在Subject2的构造函数参数上使用了Dependency特性指定了ClassInfo参数获取注册名为“your”的对象。 现在还有一个问题，就是当一个类存在多个构造函数的时候，我们如何区分哪个构造函数需要实现注入，哪个不需要？ 这时就可以使用InjectionConstructor特性来标识，代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 |
[InjectionConstructor] public Subject2([Dependency("your")] IClass classInfo) { classInfo.Name = "班级1"; } public Subject2(IClass classInfo1, IClass classInfo2) { classInfo1.Name = "班级1"; classInfo2.Name = "班级2"; } |
Unity只会调用标识了InjectionConstructor特性的构造函数，这样就很好的解决了多构造函数的情况下，Unity调用哪个构造函数。 二、属性注入 属性注入和构造函数注入类似，只需在需要注入的属性上增加一个Dependency特性，同样的也可以为Dependency指定一个name参数用来指定注入属性的具体对象，如下代码，在Subject属性上增加了Dependency特性，来表示这个属性需要注入：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
public class MyClass : IClass { public MyClass() { } public void ShowInfo() { Console.WriteLine("这个是我的班级"); } [Dependency("Subject1")] public ISubject Subject { get; set; } public string Name { get; set; } public string Description { get; set; } } |
具体的调用代码：
|
1 2 3 4 5 6 7 |
public static void PropertyInjection() { container.RegisterType<ISubject, Subject1>("Subject1") .RegisterType<IClass,MyClass>(); var classInfo = container.Resolve<IClass>(); Console.WriteLine(classInfo.Subject.Name); } |
这样ClassInfo的Subject属性自动关联到了Subject1类上（完成了属性注入），访问classInfo.Subject.Name可以得到“科目1”。 三、方法注入 方法注入同样只需在需要注入的方法上增加一个特性——InjectionMethod既可（其使用方法也和构造注入类似），这样Unity会自动帮我们完成注入，方法注入和构造注入一样，同样可以在方法的参数上指定Dependency特性来指定参数所依赖的注册，下面的类代码中包含了构造注入、属性注入及方法注入，这边集合在一起展示相对来说直观一些：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
public class MyClass : IClass { public MyClass() { } public MyClass(ISubject subjectInfo) { this.TempSubject1 = subjectInfo; } public void ShowInfo() { Console.WriteLine("构造注入成功后临时科目1名称：" + this.TempSubject1.Name); Console.WriteLine("属性注入成功后临时科目名称：" + this.Subject.Name); Console.WriteLine("方法注入成功后临时科目2名称：" + this.TempSubject2.Name); } [InjectionMethod] public void Init(ISubject subjectInfo) { TempSubject2 = subjectInfo; } [Dependency("Subject1")] public ISubject Subject { get; set; } public ISubject TempSubject1 { get; set; } public ISubject TempSubject2 { get; set; } public string Name { get; set; } public string Description { get; set; } } |
具体的调用代码：
|
1 2 3 4 5 6 7 8 9 |
public static void MethodInjection() { container.RegisterType<ISubject, Subject3>("Subject1") .RegisterType<ISubject, Subject4>(); container.RegisterType<IClass, MyClass>(); var classInfo = container.Resolve<IClass>(); classInfo.ShowInfo(); } |
效果图如下： 4、使用配置完成各种注入 上面所演示的代码都是通过代码来完成对象的注入，下面演示下如何通过配置文件来配置这些注入，具体配置代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
<!--依赖注入配置，包括构造注入，方法注入和属性注入--> <alias alias="IClass" type="UnityStudyConsole.IDemo.IClass, UnityStudyConsole" /> <alias alias="MyClass" type="UnityStudyConsole.Demo.MyClass, UnityStudyConsole" /> <alias alias="ISubject" type="UnityStudyConsole.IDemo.ISubject, UnityStudyConsole" /> <alias alias="Subject3" type="UnityStudyConsole.Demo.Subject3, UnityStudyConsole" /> <alias alias="Subject4" type="UnityStudyConsole.Demo.Subject4, UnityStudyConsole" /> <container name="Third"> <register type="IClass" mapTo="MyClass"> <constructor> <param name="subjectInfo" type="ISubject"> <dependency name="subjectInfo" type="Subject4"/> </param> </constructor> <method name="Init"> <param name="subjectInfo" type="ISubject"> <dependency name="subjectInfo" type="Subject4"/> </param> </method> <property name="Subject"> <dependency name="Subject1" type="Subject3"/> </property> </register> </container> |
代码如下：
|
1 2 3 4 5 6 7 |
public static void DIConfiguration() { //获取特定配置节下已命名的配置节<container name="Third">下的配置信息 container.LoadConfiguration("Third"); var classInfo = container.Resolve<IClass>(); classInfo.ShowInfo(); } |
具体的效果是和上面截图中是一样的，只不过这边的依赖注入是通过配置文件来实现的。 5、对已经创建对象进行注入 一般来说如果想实现依赖注入需要通过Unity容器来进行对象注册，然后通过Unity容器来获取对象，但是如果对象已经存在（就是不是通过Unity容器来获取的对象），这时如何来通过Unity来实现对已有的对象进行依赖注入呢？ Unity容器已经为我们提供好了这种情况的解决办法，就是BuildUp方法，看下下面的代码就能明白了：
|
1 2 3 4 5 6 7 8 9 10 11 |
public static void BuildUp() { //事先注册好ISubject和MySubject之间的关系 //并指定一个名称以方便在接口中的属性上应用[Dependency("Subject1")]特性 //具体请见IDemo.IClass container.RegisterType<ISubject, Subject1>("Subject1"); IClass classInfo = new MyClass(); IClass classInfo2 = container.BuildUp<IClass>(classInfo); Console.WriteLine(classInfo2.Subject.Name); } #endregion |
在上面的代码中，已经创建好一个对象实例了，这时只需将这个对象作为参数放入BuildUp中，同时还需指定这个对象实例所实现的接口或父类类型，这样Unity就会自动帮我们将这个已存在对象实例中各种注入。 需要注意的是，与上面所说3种依赖注入的不同的是，上面3中的依赖注入需要在具体的类中使用InjectionConstructor、InjectionMethodDependency和特性，而如果对已经存在的对象进行依赖注入，则需要将InjectionConstructor、InjectionMethod和Dependency写在这个对象实例所实现的接口或父类中，否则会报错！ 到本文为止，Unity的各种常用功能都已经介绍完毕了，各位可以下载下面的源代码进行查看，同时也可以通过Main方法中的各个方法来查看Unity的各种功能的使用： 示例代码下载：点我下载 （注意：本文示例代码是基于VS2010+Unity2.0，所以请使用VS2010打开，如果没有安装VS2010，请将相关代码复制到相应的VS中运行既可） 转自：http://www.cnblogs.com/kyo-yo/archive/2010/11/29/Learning-EntLib-Tenth-Decoupling-Your-System-Using-The-Unity-PART3-Dependency-Injection.html
View Details今天继续介绍Unity，在上一篇的文章中，我介绍了使用UnityContainer来注册对象之间的关系、注册已存在的对象之间的关系，同时着重介绍了Unity内置的各种生命周期管理器的使用方法，今天则主要介绍Unity的Register和Resolve的一些高级应用。 本篇文章将主要介绍： 1、注册类型同时初始化构造函数参数并重载调用。 2、注册类型同时初始化属性参数并重载调用。 3、延迟获取对象。 4、检索检索容器中注册信息。 一、注册类型同时初始化构造函数参数并重载调用 我们在使用Unity中注册对象之间的关系时，可能对象有相应的构造函数，构造函数中需要传递相应的参数，Unity就支持这样的注册，其主要靠InjectionConstructor这个类来完成，我们首先来看下具体的类构造函数：
|
1 2 3 4 5 |
public YourClass(string test, MyClass my) { Console.WriteLine(test); Console.WriteLine(my.ToString()); } |
这个构造函数有2个参数，一个字符串和一个MyClass类对象，相应的可以使用如下代码进行注册：
|
1 2 3 4 5 6 |
//由于所注册的对象的有带有参数的构造函数，所以注册类型时需要提供相应的参数 //这边采用InjectionConstructor这个类来实现 container.RegisterType<IClass, YourClass>( new InjectionConstructor("a", new MyClass())); Console.WriteLine("-----------默认调用输出-------------"); container.Resolve<IClass>(); |
这样既可完成对象注册的同时对构造函数参数进行注入，此时还有另外一个需求，就是虽然在注册的时候已经对构造函数参数进行了初始化，但是在调用的时候我们想更换原先注册的值，这时应该怎么办？ 在Unity中，已经帮我们解决了这个问题，我们可以通过ParameterOverride和ParameterOverrides来实现，其中ParameterOverride是针对一个参数，而ParameterOverrides是针对参数列表，有关注册参数初始化及参数重载的全部代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
public static void ResolveParameter() { //由于所注册的对象的有带有参数的构造函数，所以注册类型时需要提供相应的参数 //这边采用InjectionConstructor这个类来实现 container.RegisterType<IClass, YourClass>( new InjectionConstructor("a", new MyClass())); Console.WriteLine("-----------默认调用输出-------------"); container.Resolve<IClass>(); Console.WriteLine("-----------重载后调用输出-------------"); //以下2种Resolve方法效果是一样的 //对于参数过多的时候可以采用第2种方法，如果参数仅仅只有1个可以用第1种 //container.Resolve<IClass>(new ParameterOverride("test", "test"), // new ParameterOverride("my", "new MyClass").OnType<MyClass>()); container.Resolve<IClass>(new ParameterOverrides() { {"test","test"}, {"my",new MyClass()} }.OnType<YourClass>()); } |
其中需要注意的是： 1、在使用ParameterOverride方法来重载参数时，如果注册的参数是一个具体的对象就需要使用OnType这个扩展方法来指定对应的类型，否则会报错。 2、在使用ParameterOverrides进行重载参数时，可以使用如上面代码的方式进行指定，但是同样需要使用OnType来指定，不过这个的OnType指定的类型是注册的对象类型。 效果图如下： 可以看出，其中第一个字符串参数在重载后调用时已经发生了更改。 二、注册类型同时初始化属性并重载调用 这个初始化属性和上面的初始化参数很类似，只不过不同的是，属性的注册初始化是使用InjectionProperty，而重载属性是使用的PropertyOverride和PropertyOverrides，其使用方法也是相同的，这边就不多介绍了，代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
public static void ResolveProperty() { //注册对象关系时初始化对象的属性 container.RegisterType<IClass, MyClass>( new InjectionProperty("Name", "A班"), new InjectionProperty("Description", "A班的描述")); Console.WriteLine("-----------默认调用输出-------------"); Console.WriteLine(container.Resolve<IClass>().Name); Console.WriteLine(container.Resolve<IClass>().Description); Console.WriteLine("-----------重载后调用输出-------------"); //以下2种写法效果是一样的，同上面的构造函数参数重载 //var myClass = container.Resolve<IClass>(new PropertyOverride("Name", "重载后的A班"), // new PropertyOverride("Description", "重载后的A班的描述")); var myClass = container.Resolve<IClass>(new PropertyOverrides() { {"Name","重载后的A班"}, {"Description","重载后的A班的描述"} }.OnType<MyClass>()); Console.WriteLine(myClass.Name); Console.WriteLine(myClass.Description); } |
效果图如下： 可以看到2个属性都已经被重载了。 Unity还为我们提供了一个DependencyOverride重载，其使用方法和参数重载、属性重载类似，这边就不演示了，不过需要注意的是DependencyOverride是针对所注册对象类型中所包含的对象类型重载，例如在A类中有构造函数参数是B类，同时也有个属性依赖于B类，当使用了DependencyOverride后，这个A对象原先注册的有关B类的依赖将全部改变。（具体可查看示例代码中的ResolveDependency） 三、延迟获取对象 Unity还有个很不错的特性就是支持延迟获取， 其本质是通过事先建立一个委托，然后再调用这个委托，看下下面的代码：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
public static void DeferringResolve() { var resolver = container.Resolve<Func<IClass>>(); //根据业务逻辑做其他事情。 //注册IClass与MyClass之间的关系 container.RegisterType<IClass, MyClass>(); //获取MyClass实例 var myClass = resolver(); var resolver2 = container.Resolve<Func<IEnumerable<IClass>>>(); //根据业务逻辑做其他事情。 //注册与IClass相关的对象。 container.RegisterType<IClass, MyClass>("my"); container.RegisterType<IClass, YourClass>("your"); //获取与IClass关联的所有命名实例 var classList = resolver2(); } |
这段代码演示了2个延迟获取的方式，都是通过将Func<T>放入Resolve<T>中来实现的，返回的是一委托，这样就可以在实际需要的时候再调用这个委托： 1、第一种是事先通过Resolve<Func<IClass>>(); 来定义获取与IClass关联的对象的委托，然后再注册IClass与MyClass之间的关系，然后再通过resolver(); 来获取。 2、第二种是事先通过Resolve<Func<IEnumerable<IClass>>>(); 来定义获取一个与IClass关联的命名实例列表的委托，然后调用相应的委托就可以一次性获取与IClass关联的所有命名实例。 这2种方式都很好的展示了Unity可以更加灵活的控制对象之间的注册与对象的调用。 四、检索容器中注册信息 当我们在不断使用Unity容器的过程中，我们有时候想看一下容器中到底注册了多少对象，以及各个对象的一些信息，如：什么对象和什么对象关联、具体的注册名称和使用的生命周期管理器，这些信息都可以在容器的Registrations属性中查看到，在Unity文档中已经有个方法来查看这些信息了，代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
public static void DisplayContainerRegistrations(IUnityContainer theContainer) { string regName, regType, mapTo, lifetime; Console.WriteLine("容器中 {0} 个注册信息:", theContainer.Registrations.Count()); foreach (ContainerRegistration item in theContainer.Registrations) { regType = item.RegisteredType.Name; mapTo = item.MappedToType.Name; regName = item.Name ?? "[默认]"; lifetime = item.LifetimeManagerType.Name; if (mapTo != regType) { mapTo = " -> " + mapTo; } else { mapTo = string.Empty; } lifetime = lifetime.Substring(0, lifetime.Length - "生命周期管理器".Length); Console.WriteLine("+ {0}{1} '{2}' {3}", regType, mapTo, regName, lifetime); } } |
具体的注册代码如下：
|
1 2 3 4 5 6 7 8 9 10 |
public static void RegisterAll() { container.RegisterType<IClass, MyClass>("my"); container.RegisterType<IClass, YourClass>("your", new ExternallyControlledLifetimeManager()); container.RegisterType<ISubject, Subject1>("subject1"); container.RegisterType<ISubject, Subject2>("subject2"); DisplayContainerRegistrations(container); } |
效果图如下： 可以看到，我在代码中注册的信息都已经很好的反应出来了。 同时如果想查看某个对象是否已经被注册，可以通过container.IsRegistered<T>来验证，这边就不演示了。 以上就是本文的所有内容了，主要介绍了Unity的Register和Resolve的一些高级应用，英文好的朋友可以直接查看Unity的官方文档。 示例代码下载：点我下载 （注意：本文示例代码是基于VS2010+Unity2.0，所以请使用VS2010打开，如果没有安装VS2010，请将相关代码复制到相应的VS中运行既可） 转自：http://www.cnblogs.com/kyo-yo/archive/2010/11/22/Learning-EntLib-Tenth-Decoupling-Your-System-Using-The-Unity-PART2-Learn-To-Use-Unity-Three.html
View Details在前一篇文章中，我简单的介绍了如何使用代码及配置文件来进行Unity容器配置，今天则继续介绍Unity容器的使用方法。 本篇文章将主要介绍： 1、注册对象之间的关系。 2、为已存在的对象注册关系。 3、Unity中Lifetime Managers介绍。 一、注册对象之间的关系 在上一篇文章中，已经简单介绍了如何使用Unity来注册对象与对象之间的关系，通过RegisterType方法来注册对象之间的关系。 首先来看下类关系图： 有2个接口类：IClass（班级接口）和ISubject（科目接口），其分别有2个实现类，现在首先要注册班级相关的对象关系，代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
public static void RegisterTypeCode() { //注册IClass与MyClass之间的关系 //此处为IClass的默认注册，每次调用Resolve<IClass>都会返回MyClass container.RegisterType<IClass, MyClass>(); //如果再次进行默认注册，将会覆盖原来的注册 //container.RegisterType<IClass, YourClass>(); //注册IClass与YourClass之间的关系 //此处多了一个参数"your"，表示一个命名注册，只有当调用Resolve<IClass>("your")时才会返回YourClass //这种注册方法解决了当需要为某个对象注册多个对应关系时的冲突 container.RegisterType<IClass, YourClass>("your"); //获取具体的对象并调用 IClass myClass = container.Resolve<IClass>(); IClass yourClass = container.Resolve<IClass>("your"); myClass.ShowInfo(); yourClass.ShowInfo(); //ResolveAll<IClass>方法可以一次性获取与IClass有注册关系的非默认对象实例 //也就是已命名注册的对象，所以列表中只有一个对象YourClass IEnumerable<IClass> classList = container.ResolveAll<IClass>(); foreach (var item in classList) { item.ShowInfo(); } } |
这段代码展示了使用RegisterType方法来注册对象之间的关系，需要注意的是，在进行命名注册的时候，所提供的命名参数是大小写敏感的，所以输入“your”和“Your”表示的不是一个对象注册。同时这边还展示了如何通过Resolve方法来获取所需的对象，以及使用ResolveAll方法来获取与指定对象关联的所有对象列表。 有关RegisterType方法的其他重载我这边就不详细介绍了，可以点此查看详细的重载方法介绍。 接下来看下如何使用配置文件来进行配置（和上一篇的例子类似），配置文件代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 |
<unity xmlns="http://schemas.microsoft.com/practices/2010/unity"> <alias alias="IClass" type="UnityStudyConsole.IDemo.IClass, UnityStudyConsole" /> <alias alias="MyClass" type="UnityStudyConsole.Demo.MyClass, UnityStudyConsole" /> <alias alias="YourClass" type="UnityStudyConsole.Demo.YourClass, UnityStudyConsole" /> <container name="First"> <register type="IClass" mapTo="MyClass" /> <register type="IClass" mapTo="YourClass" name="your" /> </container> </unity> <span style="font-family: Verdana;">读取并调用代码如下：</span> |
|
1 2 3 4 5 6 7 8 9 10 |
public static void RegisterTypeCodeConfiguration() { //获取指定名称的配置节 UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity"); container.LoadConfiguration(section, "First"); IClass classInfo = container.Resolve<IClass>(); classInfo.ShowInfo(); } |
二、为已存在的对象注册关系 在日常开发的过程中我们有时候会自己创建好一个对象，但是你又想对这个已经创建好的对象的生命周期进行管理，这个时候你可以使用Unity提供的RegisterInstance方法，代码示例如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public static void RegisterInstance() { IClass myClass = new MyClass(); IClass yourClass = new YourClass(); //为myClass实例注册默认实例 container.RegisterInstance<IClass>(myClass); //为yourClass实例注册命名实例，同RegisterType container.RegisterInstance<IClass>("yourInstance", yourClass); container.Resolve<IClass>().ShowInfo(); container.Resolve<IClass>("yourInstance").ShowInfo(); } |
这段代码很简单，就是通过RegisterInstance方法为已存在的对象进行注册，这样可以通过UnityContainer来管理这些对象实例的生命周期。 需要注意的是，使用RegisterInstance来将已存在的实例注册到UnityContainer中，默认情况下其实用的是ContainerControlledLifetimeManager，这个生命周期是由UnityContainer来进行管理，UnityContainer会维护一个对象实例的强引用，当你将已存在的实例注册到UnityContainer后，每次通过Resolve方法获取对象都是同一对象，也就是单件实例（singleton instance），具体有关生命周期相关信息在下面进行介绍。 由于RegisterInstance是对已存在的实例进行注册，所以无法通过配置文件来进行配置。 有关RegisterInstance方法的其他重载我这边就不详细介绍了，可以点此查看详细的重载方法介绍。 三、Unity中Lifetime Managers介绍 我们在系统中引入Unity主要就是想通过Unity来解除对象之间的依赖关系，方便我们根据配置调用到所需的对象，而Unity默认情况下会自动帮我们维护好这些对象的生命周期，可能Unity自动维护的生命周期并不是我们想要的，我们想要根据具体的需求来更改这些对象的生命周期，下面我就介绍一下Unity中内置的生命周期管理器。 1、TransientLifetimeManager，瞬态生命周期，默认情况下，在使用RegisterType进行对象关系注册时如果没有指定生命周期管理器则默认使用这个生命周期管理器，这个生命周期管理器就如同其名字一样，当使用这种管理器的时候，每次通过Resolve或ResolveAll调用对象的时候都会重新创建一个新的对象。 需要注意的是，使用RegisterInstance对已存在的对象进行关系注册的时候无法指定这个生命周期，否则会报异常。 代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 |
public static void TransientLifetimeManagerCode() { //以下2种注册效果是一样的 container.RegisterType<IClass, MyClass>(); container.RegisterType<IClass, MyClass>(new TransientLifetimeManager()); Console.WriteLine("-------TransientLifetimeManager Begin------"); Console.WriteLine("第一次调用RegisterType注册的对象HashCode:" + container.Resolve<IClass>().GetHashCode()); Console.WriteLine("第二次调用RegisterType注册的对象HashCode:" + container.Resolve<IClass>().GetHashCode()); Console.WriteLine("-------TransientLifetimeManager End------"); } |
配置文件如下：
|
1 2 3 4 5 |
<register type="IClass" mapTo="MyClass"> <lifetime type="transient" /> <!--<lifetime type="SessionLifetimeManager" value="Session#1" typeConverter="SessionLifetimeConverter" />--> </register> |
如果想在配置文件中在在注册关系的时候更改一个生命周期管理器只需在<register>配置节下新增<lifetime>既可（如果不新增则默认使用TransientLifetimeManager）。 其中<lifetime>有3个参数： 1）type，生命期周期管理器的类型，这边可以选择Unity内置的，也可以使用自定义的，其中内置的生命周期管理器会有智能提示。 2）typeConverter，生命周期管理器转换类，用户自定义一个生命周期管理器的时候所创建一个转换器。 3）value，初始化生命周期管理器的值。 配置文件读取代码：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public static void TransientLifetimeManagerConfiguration() { //获取指定名称的配置节 UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity"); container.LoadConfiguration(section, "First"); Console.WriteLine("-------TransientLifetimeManager Begin------"); Console.WriteLine("第一次调用RegisterType注册的对象HashCode:" + container.Resolve<IClass>("transient").GetHashCode()); Console.WriteLine("第二次调用RegisterType注册的对象HashCode:" + container.Resolve<IClass>("transient").GetHashCode()); Console.WriteLine("-------TransientLifetimeManager End------"); } |
效果图如下，可以看出每次产生的对象都是不同的： 2、ContainerControlledLifetimeManager，容器控制生命周期管理，这个生命周期管理器是RegisterInstance默认使用的生命周期管理器，也就是单件实例，UnityContainer会维护一个对象实例的强引用，每次调用的时候都会返回同一对象，示例代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
public static void ContainerControlledLifetimeManagerCode() { IClass myClass = new MyClass(); //以下2种注册效果是一样的 container.RegisterInstance<IClass>("ccl", myClass); container.RegisterInstance<IClass>("ccl", myClass, new ContainerControlledLifetimeManager()); container.RegisterType<IClass, MyClass>(new ContainerControlledLifetimeManager()); Console.WriteLine("-------ContainerControlledLifetimeManager Begin------"); Console.WriteLine("第一次调用RegisterType注册的对象HashCode:" + container.Resolve<IClass>().GetHashCode()); Console.WriteLine("第二次调用RegisterType注册的对象HashCode:" + container.Resolve<IClass>().GetHashCode()); Console.WriteLine("第一次调用RegisterInstance注册的对象HashCode:" + container.Resolve<IClass>("ccl").GetHashCode()); Console.WriteLine("第二次调用RegisterInstance注册的对象HashCode:" + container.Resolve<IClass>("ccl").GetHashCode()); Console.WriteLine("-------ContainerControlledLifetimeManager End------"); } |
配置文件如下：
|
1 2 3 |
<register type="IClass" mapTo="MyClass" name="ccl"> <lifetime type="singleton" /> </register> |
效果图如下，可以看出每次获取的对象都是同一对象： 3、HierarchicalLifetimeManager，分层生命周期管理器，这个管理器类似于ContainerControlledLifetimeManager，也是由UnityContainer来管理，也就是单件实例。不过与ContainerControlledLifetimeManager不同的是，这个生命周期管理器是分层的，因为Unity的容器时可以嵌套的，所以这个生命周期管理器就是针对这种情况，当使用了这种生命周期管理器，父容器和子容器所维护的对象的生命周期是由各自的容器来管理，代码如下（RegisterInstance情况也类似，这边就不展示了）：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
public static void HierarchicalLifetimeManagerCode() { container.RegisterType<IClass, MyClass>(new HierarchicalLifetimeManager()); //创建子容器 var childContainer = container.CreateChildContainer(); childContainer.RegisterType<IClass, MyClass>(new HierarchicalLifetimeManager()); Console.WriteLine("-------ContainerControlledLifetimeManager Begin------"); Console.WriteLine("第一次调用父容器注册的对象HashCode:" + container.Resolve<IClass>().GetHashCode()); Console.WriteLine("第二次调用父容器注册的对象HashCode:" + container.Resolve<IClass>().GetHashCode()); Console.WriteLine("第一次调用子容器注册的对象HashCode:" + childContainer.Resolve<IClass>().GetHashCode()); Console.WriteLine("第二次调用子容器注册的对象HashCode:" + childContainer.Resolve<IClass>().GetHashCode()); Console.WriteLine("-------ContainerControlledLifetimeManager End------"); } |
由于配置文件不能配置这种层级效果，所以配置这种生命周期时只需要更改下生命周期名称：
|
1 2 3 |
<register type="IClass" mapTo="MyClass" name="hl"> <lifetime type="hierarchical" /> </register> |
具体的效果图如下，可以看出父级和子级维护不同对象实例： 这边需要提一下的就是，Unity这种分级容器的好处就在于我们可以对于有不同生命周期的对象放在不同的容器中，如果一个子容器被释放，不会影响到其它子容器中的对象，但是如果根节点处父容器释放后，所有的子容器都将被释放。 4、PerResolveLifetimeManager，这个生命周期是为了解决循环引用而重复引用的生命周期，先看一下微软官方给出的实例：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
public interface IPresenter { } public class MockPresenter : IPresenter { public IView View { get; set; } public MockPresenter(IView view) { View = view; } } public interface IView { IPresenter Presenter { get; set; } } public class View : IView { [Dependency] public IPresenter Presenter { get; set; } } |
从这个例子中可以看出，有2个接口IPresenter和IView，还有2个类MockPresenter和View分别实现这2个接口，同时这2个类中都包含了对另外一个类的对象属性，这个就是一个循环引用，而对应的这个生命周期管理就是针对这种情况而新增的，其类似于TransientLifetimeManager，但是其不同在于，如果应用了这种生命周期管理器，则在第一调用的时候会创建一个新的对象，而再次通过循环引用访问到的时候就会返回先前创建的对象实例（单件实例），代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
public static void PerResolveLifetimeManagerCode() { var container = new UnityContainer() .RegisterType<IPresenter, MockPresenter>() .RegisterType<IView, View>(new PerResolveLifetimeManager()); var view = container.Resolve<IView>(); var tempPresenter = container.Resolve<IPresenter>(); var realPresenter = (MockPresenter)view.Presenter; Console.WriteLine("-------PerResolveLifetimeManager Begin------"); Console.WriteLine("使用了PerResolveLifetimeManager的对象 Begin"); Console.WriteLine("通过Resolve方法获取的View对象：" + view.GetHashCode()); Console.WriteLine("View对象中的Presenter对象所包含的View对象：" + realPresenter.View.GetHashCode()); Console.WriteLine("使用了PerResolveLifetimeManager的对象 End"); Console.WriteLine(""); Console.WriteLine("未使用PerResolveLifetimeManager的对象 Begin"); Console.WriteLine("View对象中的Presenter对象：" + realPresenter.GetHashCode()); Console.WriteLine("通过Resolve方法获取的View对象：" + tempPresenter.GetHashCode()); Console.WriteLine("未使用PerResolveLifetimeManager的对象 End"); Console.WriteLine("-------PerResolveLifetimeManager Begin------"); } |
从代码中可以看出，在注册对象的时候，仅对IView和View应用了PerResolveLifetimeManager，所以第二次访问View对象会返回同一实例。 具体配置文件如下，有关构造函数注入和属性注入的内容在下一篇文章中进行介绍：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
<alias alias="IPresenter" type="UnityStudyConsole.IPresenter, UnityStudyConsole" /> <alias alias="IView" type="UnityStudyConsole.IView, UnityStudyConsole" /> <alias alias="MockPresenter" type="UnityStudyConsole.MockPresenter, UnityStudyConsole" /> <alias alias="View" type="UnityStudyConsole.View, UnityStudyConsole" /> <container name="Second"> <register type="IPresenter" mapTo="MockPresenter"> <constructor> <param name ="view" type="IView"> </param> </constructor> </register> <register type="IView" mapTo="View" > <lifetime type="perresolve"/> <property name="Presenter" dependencyType="IPresenter"></property> </register> </container> |
读取配置文件代码类似于前面其他配置文件读取代码，这里就不展示，具体请看示例代码。 具体的效果图如下： 可以看出2次调用View对象的HashCode都是一样的，而Presenter对象的HashCode不同。 5、PerThreadLifetimeManager，每线程生命周期管理器，就是保证每个线程返回同一实例，具体代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
public static void PerThreadLifetimeManagerCode() { container.RegisterType<IClass, MyClass>(new PerThreadLifetimeManager()); var thread = new Thread(new ParameterizedThreadStart(Thread1)); Console.WriteLine("-------PerResolveLifetimeManager Begin------"); Console.WriteLine("默认线程 Begin"); Console.WriteLine("第一调用:" + container.Resolve<IClass>().GetHashCode()); Console.WriteLine("第二调用:" + container.Resolve<IClass>().GetHashCode()); Console.WriteLine("默认线程 End"); thread.Start(container); } public static void Thread1(object obj) { var tmpContainer = obj as UnityContainer; Console.WriteLine("新建线程 Begin"); Console.WriteLine("第一调用:" + tmpContainer.Resolve<IClass>().GetHashCode()); Console.WriteLine("第二调用:" + tmpContainer.Resolve<IClass>().GetHashCode()); Console.WriteLine("新建线程 End"); |
Console.WriteLine("——-PerResolveLifetimeManager End——"); }
|
1 |
有关配置相关的代码与前面的生命周期管理器差不多，这边就不贴代码了，请看示例代码。 具体效果图如下： 同时需要注意的是，一般来说不建议在使用RegisterInstance对已存在的对象注册关系时使用PerThreadLifetimeManager，因为此时的对象已经在一个线程内创建了，如果再使用这个生命周期管理器，将无法保证其正确调用。 6、ExternallyControlledLifetimeManager，外部控制生命周期管理器，这个生命周期管理允许你使用RegisterType和RegisterInstance来注册对象之间的关系，但是其只会对对象保留一个弱引用，其生命周期交由外部控制，也就是意味着你可以将这个对象缓存或者销毁而不用在意UnityContainer，而当其他地方没有强引用这个对象时，其会被GC给销毁掉。 在默认情况下，使用这个生命周期管理器，每次调用Resolve都会返回同一对象（单件实例），如果被GC回收后再次调用Resolve方法将会重新创建新的对象，示例代码如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
public static void ExternallyControlledLifetimeManagerCode() { container.RegisterType<IClass, MyClass>(new ExternallyControlledLifetimeManager()); var myClass1 = container.Resolve<IClass>(); var myClass2 = container.Resolve<IClass>(); Console.WriteLine("-------ExternallyControlledLifetimeManager Begin------"); Console.WriteLine("第一次调用：" + myClass1.GetHashCode()); Console.WriteLine("第二次调用：" + myClass2.GetHashCode()); myClass1 = myClass2 = null; GC.Collect(); Console.WriteLine("****GC回收过后****"); Console.WriteLine("第一次调用：" + container.Resolve<IClass>().GetHashCode()); Console.WriteLine("第二次调用：" + container.Resolve<IClass>().GetHashCode()); Console.WriteLine("-------ExternallyControlledLifetimeManager End------"); } |
有关配置相关的代码与前面的生命周期管理器差不多，这边就不贴代码了，请看示例代码。 效果图如下： 以上就是本文的全部内容了，主要介绍了使用UnityContainer来注册对象之间的关系、注册已存在的对象之间的关系和Unity内置的生命周期管理器。 示例代码下载：点我下载 （注意：本文示例代码是基于VS2010+Unity2.0，所以请使用VS2010打开，如果没有安装VS2010，请将相关代码复制到相应的VS中运行既可） 转自：http://www.cnblogs.com/kyo-yo/archive/2010/11/10/Learning-EntLib-Tenth-Decoupling-Your-System-Using-The-Unity-PART2-Learn-To-Use-Unity-Two.html
View Details1. Stylish jQuery Accordion 一个完全可定制的卷帘插件，可用于在有限的区域显示很多的文本和图片数据 下载插件 (Free) 2. HorizontalNav 水平导航菜单自动扩展宽度到父一层元素的宽度，这是实现响应式优雅菜单的好方法。 下载插件 (Free) 3. jQuery Sidebar 在你的网页上显示可扩展的边栏 下载插件 (Free) 4. PageScroller 为你的网页添加平滑的滚动导航 下载插件 (Lite version free or $35) 5. Explr 轻量级和可定制的树状菜单 下载插件 ($6) 6. Sticky Mojo 可固定在网页某个位置的边栏，不跟随页面的滚动更改变位置 下载插件 (Free) 7. ddSlick 下拉菜单，带图片和描述 下载插件 (Free) 8. CSS Dock menu Mac 风格的菜单 下载插件 (Free) 9. Metro flexible navigation Metro 风格的菜单 下载插件 ($6) 10. Filtrify 外观超棒的标签过滤插件 下载插件 (Free) via designer-daily 转自：http://www.oschina.net/news/39290/10-jquery-plugins-for-better-website-navigation
View Details