首先要在项目中安装Unity，通过NuGet搜索Unity。

1.定义接口 IDependencyResolver

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. namespace IOCContainer
  8. {
  9.     public interface IDependencyResolver : IDisposable
  10.     {
  11.         /// <summary>
  12.         /// 注册 T类型实例
  13.         /// </summary>
  14.         /// <typeparam name="T"></typeparam>
  15.         /// <param name="instance"></param>
  16.         void Register<T>(T instance);
  17.  
  18.         /// <summary>
  19.         /// 注入
  20.         /// </summary>
  21.         /// <typeparam name="T"></typeparam>
  22.         /// <param name="existing"></param>
  23.         void Inject<T>(T existing);
  24.  
  25.         /// <summary>
  26.         /// 解析
  27.         /// </summary>
  28.         /// <typeparam name="T"></typeparam>
  29.         /// <param name="type"></param>
  30.         /// <returns></returns>
  31.         T Resolve<T>(Type type);
  32.  
  33.         T Resolve<T>(Type type, string name);
  34.  
  35.         T Resolve<T>();
  36.  
  37.         T Resolve<T>(string name);
  38.  
  39.         IEnumerable<T> ResolveAll<T>();
  40.     }
  41. }

　　

2.具体实现接口 UnityDependencyResolver

  1. using Microsoft.Practices.Unity;
  2. using Microsoft.Practices.Unity.Configuration;
  3. using System;
  4. using System.Collections.Generic;
  5. using System.Collections.ObjectModel;
  6. using System.Configuration;
  7. using System.Diagnostics;
  8. using System.Linq;
  9. using System.Text;
  10. using System.Threading.Tasks;
  11.  
  12. namespace IOCContainer
  13. {
  14.     [Serializable]
  15.     public class UnityDependencyResolver : IDisposable, IDependencyResolver
  16.     {
  17.         //注入容器
  18.         private IUnityContainer _container;
  19.  
  20.         public UnityDependencyResolver() : this(new UnityContainer())
  21.         {
  22.             UnityConfigurationSection configuration = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
  23.             _container.LoadConfiguration(configuration, "UnityContainer");
  24.         }
  25.  
  26.         public UnityDependencyResolver(IUnityContainer container)
  27.         {
  28.             _container = container;
  29.         }
  30.  
  31.         public void Register<T>(T instance)
  32.         {
  33.             //注册实例
  34.             _container.RegisterInstance(instance);
  35.         }
  36.  
  37.         public void Inject<T>(T existing)
  38.         {
  39.             //注入加载
  40.             _container.BuildUp(existing);
  41.         }
  42.  
  43.         public T Resolve<T>(Type type)
  44.         {
  45.             //解析
  46.             return (T)_container.Resolve(type);
  47.         }
  48.  
  49.         public T Resolve<T>(Type type, string name)
  50.         {
  51.             return (T)_container.Resolve(type, name);
  52.         }
  53.  
  54.         public T Resolve<T>()
  55.         {
  56.             return _container.Resolve<T>();
  57.         }
  58.  
  59.         public T Resolve<T>(string name)
  60.         {
  61.             return _container.Resolve<T>(name);
  62.         }
  63.  
  64.         public IEnumerable<T> ResolveAll<T>()
  65.         {
  66.             //解析容器中所有
  67.             IEnumerable<T> namedInstances = _container.ResolveAll<T>();
  68.             T unnamedInstance = default(T);
  69.  
  70.             try
  71.             {
  72.                 unnamedInstance = _container.Resolve<T>();
  73.             }
  74.             catch (ResolutionFailedException)
  75.             {
  76.                 //When default instance is missing
  77.             }
  78.  
  79.             if (Equals(unnamedInstance, default(T)))
  80.             {
  81.                 return namedInstances;
  82.             }
  83.  
  84.             return new ReadOnlyCollection<T>(new List<T>(namedInstances) { unnamedInstance });
  85.         }
  86.  
  87.         public void Dispose()
  88.         {
  89.             if (_container != null)
  90.             {
  91.                 _container.Dispose();
  92.             }
  93.         }
  94.     }
  95. }

　　

3.定义工厂接口 IDependencyResolverFactory

  1. using IOCContainer;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace IOCContainer
  9. {
  10.     public interface IDependencyResolverFactory
  11.     {
  12.         /// <summary>
  13.         /// 创建IDependencyResolver的实例
  14.         /// </summary>
  15.         /// <returns></returns>
  16.         IDependencyResolver CreateInstance();
  17.     }
  18. }

　　

4.具体实现工厂接口 DependencyResolverFactory

  1. using IOCContainer;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Configuration;
  5. using System.Linq;
  6. using System.Reflection;
  7. using System.Text;
  8. using System.Threading.Tasks;
  9.  
  10. namespace IOCContainer
  11. {
  12.     public class DependencyResolverFactory : IDependencyResolverFactory
  13.     {
  14.         private Type _resolverType;
  15.  
  16.         public DependencyResolverFactory(string resolverTypeName)
  17.         {
  18.             _resolverType = Type.GetType(resolverTypeName, true, true);
  19.         }
  20.  
  21.         public DependencyResolverFactory()
  22.         {
  23.             _resolverType = Type.GetType(ConfigurationManager.AppSettings["DependencyResolverTypeName"], true, true);
  24.         }
  25.  
  26.         public IDependencyResolver CreateInstance()
  27.         {
  28.             //根据类型创建实例对象
  29.             return Activator.CreateInstance(_resolverType) as IDependencyResolver;
  30.         }
  31.     }
  32. }

　　

5.调用工厂封装 IoC

  1. using IOCContainer;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Diagnostics;
  5. using System.Linq;
  6. using System.Text;
  7. using System.Threading.Tasks;
  8.  
  9. namespace IOCContainer
  10. {
  11.     public static class IoC
  12.     {
  13.         //解析器
  14.         private static IDependencyResolver _resolver;
  15.  
  16.         /// <summary>
  17.         /// 初始化，创建实例对象
  18.         /// </summary>
  19.         /// <param name="factory"></param>
  20.         [DebuggerStepThrough]
  21.         public static void InitializeWith(IDependencyResolverFactory factory)
  22.         {
  23.             _resolver = factory.CreateInstance();
  24.         }
  25.  
  26.         /// <summary>
  27.         /// 注册对象
  28.         /// </summary>
  29.         /// <typeparam name="T"></typeparam>
  30.         /// <param name="instance"></param>
  31.         [DebuggerStepThrough]
  32.         public static void Register<T>(T instance)
  33.         {
  34.             _resolver.Register(instance);
  35.         }
  36.  
  37.         /// <summary>
  38.         /// 注入对象
  39.         /// </summary>
  40.         /// <typeparam name="T"></typeparam>
  41.         /// <param name="existing"></param>
  42.         [DebuggerStepThrough]
  43.         public static void Inject<T>(T existing)
  44.         {
  45.             _resolver.Inject(existing);
  46.         }
  47.  
  48.         /// <summary>
  49.         /// 解析对象
  50.         /// </summary>
  51.         /// <typeparam name="T"></typeparam>
  52.         /// <param name="type"></param>
  53.         /// <returns></returns>
  54.         [DebuggerStepThrough]
  55.         public static T Resolve<T>(Type type)
  56.         {
  57.             return _resolver.Resolve<T>(type);
  58.         }
  59.         /// <summary>
  60.         /// 解析对象
  61.         /// </summary>
  62.         /// <typeparam name="T"></typeparam>
  63.         /// <param name="type"></param>
  64.         /// <param name="name"></param>
  65.         /// <returns></returns>
  66.         [DebuggerStepThrough]
  67.         public static T Resolve<T>(Type type, string name)
  68.         {
  69.             return _resolver.Resolve<T>(type, name);
  70.         }
  71.         /// <summary>
  72.         /// 解析对象
  73.         /// </summary>
  74.         /// <typeparam name="T"></typeparam>
  75.         /// <returns></returns>
  76.         [DebuggerStepThrough]
  77.         public static T Resolve<T>()
  78.         {
  79.             return _resolver.Resolve<T>();
  80.         }
  81.         /// <summary>
  82.         /// 解析对象
  83.         /// </summary>
  84.         /// <typeparam name="T"></typeparam>
  85.         /// <param name="name"></param>
  86.         /// <returns></returns>
  87.         [DebuggerStepThrough]
  88.         public static T Resolve<T>(string name)
  89.         {
  90.             return _resolver.Resolve<T>(name);
  91.         }
  92.         /// <summary>
  93.         /// 解析对象
  94.         /// </summary>
  95.         /// <typeparam name="T"></typeparam>
  96.         /// <returns></returns>
  97.         [DebuggerStepThrough]
  98.         public static IEnumerable<T> ResolveAll<T>()
  99.         {
  100.             return _resolver.ResolveAll<T>();
  101.         }
  102.         /// <summary>
  103.         /// 销毁
  104.         /// </summary>
  105.         [DebuggerStepThrough]
  106.         public static void Reset()
  107.         {
  108.             if (_resolver != null)
  109.             {
  110.                 _resolver.Dispose();
  111.             }
  112.         }
  113.     }
  114. }

6.配置文件

  1. <configuration>
  2.   <configSections>
  3.     <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->
  4.     <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
  5.  
  6.     <!--声明容器-->
  7.     <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration"/>
  8.  
  9.   </configSections>
  10.  
  11.   <unity>
  12.     <!--定义类型别名-->
  13.     <aliases>
  14.       <add alias="IProduct" type="UnityTest.IProduct,UnityTest" />
  15.       <add alias="Milk" type="UnityTest.Milk,UnityTest" />
  16.       <add alias="Sugar" type="UnityTest.Sugar,UnityTest" />
  17.     </aliases>
  18.     <!--容器-->
  19.     <container name="UnityContainer">
  20.       <!--映射关系-->
  21.       <register type="IProduct"  mapTo="Milk"  name="Milk"></register>
  22.       <register type="IProduct"  mapTo="Sugar" name="Sugar"></register>
  23.     </container>
  24.   </unity>
  25.  
  26.   <connectionStrings>
  27.     <add name="DefaultConnection" connectionString="Data Source=(LocalDb)\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\aspnet-UnityTest-20160816022913.mdf;Initial Catalog=aspnet-UnityTest-20160816022913;Integrated Security=True" providerName="System.Data.SqlClient" />
  28.   </connectionStrings>
  29.   <appSettings>
  30.     <add key="webpages:Version" value="3.0.0.0" />
  31.     <add key="webpages:Enabled" value="false" />
  32.     <add key="ClientValidationEnabled" value="true" />
  33.     <add key="UnobtrusiveJavaScriptEnabled" value="true" />
  34.  
  35.     <!--Unity IOC容器-->
  36.     <add key="DependencyResolverTypeName" value="IOCContainer.UnityDependencyResolver,IOCContainer"/>
  37.  
  38.   </appSettings>
  39.     <!--省略了其他配置...-->
  40. </configuration>

　　

7.具体实体类

  1. /// <summary>
  2.     /// 商品
  3.     /// </summary>
  4.     public interface IProduct
  5.     {
  6.         string ClassName { get; set; }
  7.         string ShowInfo();
  8.     }
  9.     /// <summary>
  10.     /// 牛奶
  11.     /// </summary>
  12.     public class Milk : IProduct
  13.     {
  14.         public string ClassName { get; set; }
  15.         public string ShowInfo()
  16.         {
  17.             return "牛奶";
  18.         }
  19.     }
  20.     /// <summary>
  21.     /// 糖
  22.     /// </summary>
  23.     public class Sugar : IProduct
  24.     {
  25.         public string ClassName { get; set; }
  26.         public string ShowInfo()
  27.         {
  28.             return "糖";
  29.         }
  30.     }

8.使用Ioc得到对象

  1. 　　　　　　　//初始化 指定注册器
  2.             IoC.InitializeWith(new DependencyResolverFactory("IOCContainer.UnityDependencyResolver"));
  3.             //初始化 使用默认注册器，配置文件中配置，IOCContainer.UnityDependencyResolver 的无参构造函数
  4.             //IoC.InitializeWith(new DependencyResolverFactory());
  5.  
  6.             //得到实例
  7.             IProduct sugar = IoC.Resolve<IProduct>("Sugar");
  8.             string result = sugar.ShowInfo();
  9.             Response.Write(result);

　　来源：http://www.cnblogs.com/qqlin/archive/2012/10/18/2720830.html

Unity（四）IocContainer 封装类库的更多相关文章

  1. Echarts 的 Java 封装类库 转自 https://my.oschina.net/flags/blog/316920

    转自: https://my.oschina.net/flags/blog/316920 Echarts 的 Java 封装类库:http://www.oschina.net/p/echarts-ja ...

  2. RxHttp - 轻量级、可扩展、易使用、完美兼容MVVM、MVC架构的网络封装类库

    前言 RxHttp是基于RxJava2+Retrofit 2.9.0+OkHttp 4.9.0实现的轻量级,完美兼容MVVM架构的网络请求封装类库,小巧精致,简单易用,轻轻松松搞定网络请求. GitH ...

  3. STC8H开发(四): FwLib_STC8 封装库的介绍和注意事项

    目录 STC8H开发(一): 在Keil5中配置和使用FwLib_STC8封装库(图文详解) STC8H开发(二): 在Linux VSCode中配置和使用FwLib_STC8封装库(图文详解) ST ...

  4. 基础拾遗----RabbitMQ（含封装类库源码）

    基础拾遗 基础拾遗------特性详解 基础拾遗------webservice详解 基础拾遗------redis详解 基础拾遗------反射详解 基础拾遗------委托详解 基础拾遗----- ...

  5. unity 代码C#封装为dll

    1  Visual studio软件打开后创建一个项目 2并选择类库类型 3编写简单的代码看看效果(发现会报错),主要是没有添加类库,以及using UnityEngine;引用空间 4添加类库,引用 ...

  6. 【开源项目12】Retrofit – Java(Android) 的REST 接口封装类库

    Retrofit官网:http://square.github.io/retrofit/ Retrofit 和Java领域的ORM概念类似, ORM把结构化数据转换为Java对象,而Retrofit ...

  7. Retrofit – Java(Android) 的REST 接口封装类库

    Retrofit 和Java领域的ORM概念类似, ORM把结构化数据转换为Java对象,而Retrofit 把REST API返回的数据转化为Java对象方便操作.同时还封装了网络代码的调用. 例如 ...

  8. Unity属性的封装、继承、方法隐藏

    (一)Unity属性封装.继承.方法隐藏的学习和总结 一.属性的封装 1.属性封装的定义:通过对属性的读和写来保护类中的域. 2.格式例子: private string departname; // ...

  9. Mongodb for .Net Core 封装类库

    一:引用的mongodb驱动文件版本为 Mongodb.Driver 20.4.3 二:我只是进行了常用方法的封装,如有不当之处,请联系我 创建mongodb的连接 using MongoDB.Bso ...

随机推荐

  1. gulp和grunt的区别

    1. Grunt -> Gulp 早些年提到构建工具,难免会让人联想到历史比较悠久的Make,Ant,以及后来为了更方便的构建结构类似的Java项目而出现的Maven.Node催生了一批自动化工 ...

  2. ES6与ES5差别

    1.ES6新增了let命令,用来声明变量.它的用法类似于var,但是所声明的变量,只在let命令所在的代码块内有效. { var a = 1; let b = 1; } a; b;/ let不像var ...

  3. angularjs上传图片

    通过AngularJS实现图片上传及缩略图展示(读取文件内容) AngularJS图片上传功能的实现(读取文件内容) AngularJs实现Multipart/form-data 文件的上传(上传文件 ...

  4. javascript call与apply关键字的作用

    apply接受两个参数.第一个参数指定函数体内this对象的指向,第二个参数为一个带下标的集合. call则是apply的语法糖,如果参数数量固定,则可以不用带下标的集合传第二个参数. 1 2 3 4 ...

  5. for 小曦

    安装GO 当前版本1.6.2 http://blog.163.com/hehaifeng1984@126/blog/static/690011362013101044011568/ 教程 https: ...

  6. 使用generator生成排序动画

    相信作为一个程序猿,大家应该都已经看过一些排序算法的过程教学动画,现在我来总结一下自己使用ES6的generator实现动画的过程,以作为自己对generator的使用实践的一个记录. 为什么用gen ...

  7. [转]逻辑斯蒂回归 via python

    # -*- coding:UTF-8 -*-import numpydef loadDataSet(): return dataMat,labelMat def sigmoid(inX): retur ...

  8. Druid监控Mybatis不显示SQL问题

    一.Web.xml增加如下配置: 1.DruidWebStatFilter.如果没有配置filter信息.session监控,web监控等不可用.没有配置 <filter> <fil ...

  9. ［原创］纯JS实现网页中多选复选框checkbox和单选radio的美化效果

    图片素材: 最终效果图: <html><title> 纯JS实现网页中多选复选框checkbox和单选radio的美化效果</title><head>& ...

  10. win10使用技巧

    无法使用内置的管理员账户打开应用的问题命令行里输入:secpol.msc安全设置-本地策略-安全选项点击找到“用户账户控制:用于内置管理员账户的管理员批准”选项.该选项设置为"已启用&quo ...