Autofac Container 的简单的封装重构

为了使用方便,对Autofac container的简单封装,记录如下,备以后用或分享给大家,欢迎讨论!

  1 using Autofac;
  2 using Autofac.Core.Lifetime;
  3 using Autofac.Integration.Mvc;
  4
  5 public static class ContainerManager
  6     {
  7         private static IContainer _container;
  8
  9         public static void SetContainer(IContainer container)
 10         {
 11             _container = container;
 12         }
 13
 14         public static IContainer Container
 15         {
 16             get { return _container; }
 17         }
 18
 19         public static T Resolve<T>(string key = "", ILifetimeScope scope = null) where T : class
 20         {
 21             if (scope == null)
 22             {
 23                 //no scope specified
 24                 scope = Scope();
 25             }
 26             if (string.IsNullOrEmpty(key))
 27             {
 28                 return scope.Resolve<T>();
 29             }
 30             return scope.ResolveKeyed<T>(key);
 31         }
 32
 33         public static object Resolve(Type type, ILifetimeScope scope = null)
 34         {
 35             if (scope == null)
 36             {
 37                 //no scope specified
 38                 scope = Scope();
 39             }
 40             return scope.Resolve(type);
 41         }
 42
 43         public static T[] ResolveAll<T>(string key = "", ILifetimeScope scope = null)
 44         {
 45             if (scope == null)
 46             {
 47                 //no scope specified
 48                 scope = Scope();
 49             }
 50             if (string.IsNullOrEmpty(key))
 51             {
 52                 return scope.Resolve<IEnumerable<T>>().ToArray();
 53             }
 54             return scope.ResolveKeyed<IEnumerable<T>>(key).ToArray();
 55         }
 56
 57         public static T ResolveUnregistered<T>(ILifetimeScope scope = null) where T : class
 58         {
 59             return ResolveUnregistered(typeof(T), scope) as T;
 60         }
 61
 62         public static object ResolveUnregistered(Type type, ILifetimeScope scope = null)
 63         {
 64             if (scope == null)
 65             {
 66                 //no scope specified
 67                 scope = Scope();
 68             }
 69             var constructors = type.GetConstructors();
 70             foreach (var constructor in constructors)
 71             {
 72                 try
 73                 {
 74                     var parameters = constructor.GetParameters();
 75                     var parameterInstances = new List<object>();
 76                     foreach (var parameter in parameters)
 77                     {
 78                         var service = Resolve(parameter.ParameterType, scope);
 79                         if (service == null) throw new ArgumentException("Unkown dependency");
 80                         parameterInstances.Add(service);
 81                     }
 82                     return Activator.CreateInstance(type, parameterInstances.ToArray());
 83                 }
 84                 catch (ArgumentException)
 85                 {
 86
 87                 }
 88             }
 89             throw new ArgumentException("在所有的依赖项中,未找到合适的构造函数。");
 90         }
 91
 92         public static bool TryResolve(Type serviceType, ILifetimeScope scope, out object instance)
 93         {
 94             if (scope == null)
 95             {
 96                 //no scope specified
 97                 scope = Scope();
 98             }
 99             return scope.TryResolve(serviceType, out instance);
100         }
101
102         public static bool IsRegistered(Type serviceType, ILifetimeScope scope = null)
103         {
104             if (scope == null)
105             {
106                 //no scope specified
107                 scope = Scope();
108             }
109             return scope.IsRegistered(serviceType);
110         }
111
112         public static object ResolveOptional(Type serviceType, ILifetimeScope scope = null)
113         {
114             if (scope == null)
115             {
116                 //no scope specified
117                 scope = Scope();
118             }
119             return scope.ResolveOptional(serviceType);
120         }
121
122         public static ILifetimeScope Scope()
123         {
124             try
125             {
126                 if (HttpContext.Current != null)
127                     return AutofacDependencyResolver.Current.RequestLifetimeScope;
128
129                 //when such lifetime scope is returned, you should be sure that it‘ll be disposed once used (e.g. in schedule tasks)
130                 return Container.BeginLifetimeScope(MatchingScopeLifetimeTags.RequestLifetimeScopeTag);
131             }
132             catch (Exception)
133             {
134                 //we can get an exception here if RequestLifetimeScope is already disposed
135                 //for example, requested in or after "Application_EndRequest" handler
136                 //but note that usually it should never happen
137
138                 //when such lifetime scope is returned, you should be sure that it‘ll be disposed once used (e.g. in schedule tasks)
139                 return Container.BeginLifetimeScope(MatchingScopeLifetimeTags.RequestLifetimeScopeTag);
140             }
141         }
142     }

使用方法如下:

 1     /// <summary>
 2     /// IOCConfig
 3     /// </summary>
 4     public class IOCConfig
 5     {
 6         /// <summary>
 7         /// RegisterAll
 8         /// </summary>
 9         public static void RegisterAll()
10         {
11             var iocBuilder = new Autofac.ContainerBuilder();
12
13             //todo:为了能编译到web目录,并且发布方便,才在web项目中引用repository项目,在代码中不要直接使用之
14             iocBuilder.RegisterModule<RIS.Infrastructure.RegisterModule>();
15             iocBuilder.RegisterModule<RIS.Biz.RegisterModule>();
16             iocBuilder.RegisterModule<RIS.Repository.RegisterModule>();
17
18             iocBuilder.Register((c, p) => new WebWorkContext(p.Named<string>("userToken")))
19                 .As<RIS.Biz.Core.IWorkContext>()
20                 .InstancePerLifetimeScope();
21
22
23             iocBuilder.RegisterControllers(Assembly.GetExecutingAssembly());
24
25             iocBuilder.RegisterApiControllers(Assembly.GetExecutingAssembly());
26
27             //iocBuilder.RegisterModelBinders(Assembly.GetExecutingAssembly());
28             //iocBuilder.RegisterModelBinderProvider();
29             //iocBuilder.RegisterModule<AutofacWebTypesModule>();
30             var config = GlobalConfiguration.Configuration;
31             iocBuilder.RegisterWebApiFilterProvider(config);
32             IContainer iocContainer = iocBuilder.Build();
33             config.DependencyResolver = new AutofacWebApiDependencyResolver(iocContainer);
34             System.Web.Mvc.DependencyResolver.SetResolver(new AutofacDependencyResolver(iocContainer));
35
36
37             RIS.Biz.Core.ContainerManager.SetContainer(iocContainer);
38         }
39     }
40
41     // 注意: 有关启用 IIS6 或 IIS7 经典模式的说明,
42     // 请访问 http://go.microsoft.com/?LinkId=9394801
43     /// <summary>
44     /// MvcApplication
45     /// </summary>
46     public class MvcApplication : System.Web.HttpApplication
47     {
48         /// <summary>
49         /// 程序启动入口
50         /// </summary>
51         protected void Application_Start()
52         {
53             IOCConfig.RegisterAll();
54
55             AreaRegistration.RegisterAllAreas();
56
57             WebApiConfig.Register(GlobalConfiguration.Configuration);
58             FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
59             RouteConfig.RegisterRoutes(RouteTable.Routes);
60             BundleConfig.RegisterBundles(BundleTable.Bundles);
61         }
62     }
时间: 2024-10-29 01:12:50

Autofac Container 的简单的封装重构的相关文章

html --- ajax --- javascript --- 简单的封装

Ajax的简单封装 Ajax的全称是AsynchronousJavaScriptAndXML 如有疑问请参考:http://zh.wikipedia.org/zh-cn/AJAX 以及传智播客的视频教程:http://java.itcast.cn/news/8308d118/740a/4dcd/8dbf/c73d2fe5bc60.shtml 其实已经有好多框架对它进行了封装,但是还是有好多时候用到自己封装的 透露一下,本人是宇多田光的听众之一哦! 封装后的代码如下: 文件路径:\web\Ajax

最新 AFNetworking 3.0 简单实用封装

AFNetworking 3.0 的到来使我们开发者又方便了许多,话不多说,直接上代码. 1.首先 引入框架AFNetworking框架 GitHub下载地址:https://github.com/AFNetworking/AFNetworking AFNetworking官网地址:http://afnetworking.com 2.导入AFNetworking 支持框架 #import<MobileCoreServices/MobileCoreServices.h> #import<S

对bootstrap modal的简单扩展封装

对bootstrap modal的简单扩展封装 参考自:http://www.muzilei.com/archives/677   注:原文不支持bootstrap新版本,并且居中等存在问题 此段时间一直在学习bootstrap,主要是用于做后台,一直习惯用easyui,ui,jgrid前端框架,以至于并不习惯bootstrap的风格.近来考虑到easyui性能不太好,就用了bootstrap,先说下我所了解的bootstrap. 1.外国的框架用于显示中文看着总是不妥. 2.默认的样式觉得有些

一个用python简单的封装了aria2的jsonrpc中adduri的脚本

aria2是一个十分牛逼的下载神器,有时候项目需要一个很牛逼的下载中间件的话,aria2是一个不错的选择.其中支持jsonrpc和websocket的特性尤其诱人.但是python用起来还是有点不爽,所以简单封装一下aria2的jsonrpc. 所以,用python简单的封装了aria2的jsonrpc中adduri的脚本. 使用起来非常简单,仅需要三行代码. from pyaria2 import Jsonrpc jsonrpc = Jsonrpc('localhost', 6800) res

React+Echarts简单的封装套路

今天我们来介绍一下React中,对Echarts的一个简单的封装. 首先在我们的React项目中,想使用Echart包,首先需要先安装它,安装代码如下,任选一个就可以 cnpm install echarts --save npm install echarts --save yarn add echarts --save 安装好之后,新建一个JS文件,命名test.js,首先导入的是各种依赖(总代码在文章结尾) import React from 'react'; import echarts

SSH 项目中 用Hibernate底层 简单的封装DAO层

废话不多少了,主要是使用hibernate的查询方法,自己封装了DAO层,供service来方便使用. 首先:必须要继承的 public class CommonDao extends HibernateDaoSupport 紧接着是要注入必须的数据源: @Resource private SessionFactory sessionFactory; @PostConstruct public void initSessionFactory() { super.setSessionFactory

[分享] 史上最简单的封装教程,五分钟学会封装系统(以封装Windows 7为例)

踏雁寻花 发表于 2015-8-23 23:31:28 https://www.itsk.com/thread-355923-1-4.html 学会封装,只需要掌握十个步骤.五分钟包你学会,不会不交学费~ 适合人群: 1.会装系统 2.了解PE的使用 3.对注册表有初步的了解 所需工具: 1.Windows系统镜像 2.PE(可以放到U盘,如果使用虚拟机封装系统,直接下载PE镜像即可) 3.磁盘清理工具(如Windows7瘦身工具.自由天空系统清理&减肥程序.注册表减肥工具等) 4.驱动包(如万

iOS简单runtime封装fmdb的使用

学习了iOS有一段时间了,使用到fmdb操作数据库的时候感觉有很多重复性的工作要做,查询数据库时面向对象性感觉很差,一个查询只能针对一个Model,经过了解发现了runtime的使用可以解决这一问题. 使用fmdb的时候相信有过这样的经历查询某个model时: NSString *sql = @"select * from myFmdb"; FMResultSet *set = [self.database executeQuery:sql]; while (set.next) { i

asp.net泛型结合反射的简单Base封装

泛型(generic)是C#语言2.0和通用语言运行时(CLR)的一个新特性.泛型为.NET框架引入了类型参数(type parameters)的概念.类型参数使得设计类和方法时,不必确定一个或多个具体参数,其的具体参数可延迟到客户代码中声明.实现.这意味着使用泛型的类型参数T,写一个类MyList<T>,客户代码可以这样调用:MyList<int>, MyList<string>或 MyList<MyClass>.这避免了运行时类型转换或装箱操作的代价和风