程序集准备
Assembly:
Autofac/Autofac.Integration.Mvc/System.Web.Mvc/System.Web.Helpers/System.Web.WebPages.Deployment/System.Web.WebPages/
System.Web.WebPages.Razor
版本：
Autofac:3.5.00
Autofac.Integration.Mvc：3.3.0.0
System.Web.Mvc：5.2.3.0
System.Web.Helpers：3.0.0.0
System.Web.WebPages.Deployment：3.0.0.0
System.Web.WebPages:3.0.0.0
System.Web.WebPages.Razor:3.0.0.0
开始
webconfig，packages.config 因为重新引入版本的缘故改下
1 <runtime> 2 <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"> 3 <dependentAssembly> 4 <assemblyIdentity name="System.Web.Helpers" publicKeyToken="31bf3856ad364e35"/> 5 <bindingRedirect oldVersion="1.0.0.0-3.0.0.0" newVersion="3.0.0.0"/> 6 </dependentAssembly> 7 <dependentAssembly> 8 <assemblyIdentity name="Autofac" publicKeyToken="17863af14b0044da" culture="neutral" /> 9 <bindingRedirect oldVersion="0.0.0.0-3.5.0.0" newVersion="3.5.0.0" /> 10 </dependentAssembly> 11 <dependentAssembly> 12 <assemblyIdentity name="System.Web.WebPages" publicKeyToken="31bf3856ad364e35"/> 13 <bindingRedirect oldVersion="1.0.0.0-3.0.0.0" newVersion="3.0.0.0"/> 14 </dependentAssembly> 15 <dependentAssembly> 16 <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35"/> 17 <bindingRedirect oldVersion="1.0.0.0-5.2.3.0" newVersion="5.2.3.0"/> 18 </dependentAssembly> 19 </assemblyBinding> 20 </runtime>
1 <?xml version="1.0" encoding="utf-8"?> 2 <packages> 3 <package id="bootstrap" version="3.0.0" targetFramework="net45" /> 4 <package id="jQuery" version="1.10.2" targetFramework="net45" /> 5 <package id="Microsoft.AspNet.Mvc" version="5.2.3" targetFramework="net45" /> 6 <package id="Microsoft.AspNet.Mvc.zh-Hans" version="5.2.3" targetFramework="net45" /> 7 <package id="Microsoft.AspNet.Razor" version="3.2.3" targetFramework="net45" /> 8 <package id="Microsoft.AspNet.Razor.zh-Hans" version="3.2.3" targetFramework="net45" /> 9 <package id="Microsoft.AspNet.WebPages" version="3.2.3" targetFramework="net45" /> 10 <package id="Microsoft.AspNet.WebPages.zh-Hans" version="3.2.3" targetFramework="net45" /> 11 <package id="Microsoft.CodeDom.Providers.DotNetCompilerPlatform" version="1.0.0" targetFramework="net45" /> 12 <package id="Microsoft.Net.Compilers" version="1.0.0" targetFramework="net45" developmentDependency="true" /> 13 <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net45" /> 14 <package id="Modernizr" version="2.6.2" targetFramework="net45" /> 15 </packages>
Core部分
贴代码
1.ContainerManager
/// <summary> /// Container manager /// </summary> public class ContainerManager { private readonly IContainer _container; /// <summary> /// Constructor /// </summary> /// <param name="container">Conainer</param> public ContainerManager(IContainer container) { this._container = container; } /// <summary> /// Gets a container /// </summary> public virtual IContainer Container { get { return _container; } } /// <summary> /// Resolve /// </summary> /// <typeparam name="T">Type</typeparam> /// <param name="key">key</param> /// <param name="scope">Scope; pass null to automatically resolve the current scope</param> /// <returns>Resolved service</returns> public virtual T Resolve<T>(string key = "", ILifetimeScope scope = null) where T : class { if (scope == null) { //no scope specified scope = Scope(); } if (string.IsNullOrEmpty(key)) { return scope.Resolve<T>(); } return scope.ResolveKeyed<T>(key); } /// <summary> /// Resolve /// </summary> /// <param name="type">Type</param> /// <param name="scope">Scope; pass null to automatically resolve the current scope</param> /// <returns>Resolved service</returns> public virtual object Resolve(Type type, ILifetimeScope scope = null) { if (scope == null) { //no scope specified scope = Scope(); } return scope.Resolve(type); } /// <summary> /// Resolve all /// </summary> /// <typeparam name="T">Type</typeparam> /// <param name="key">key</param> /// <param name="scope">Scope; pass null to automatically resolve the current scope</param> /// <returns>Resolved services</returns> public virtual T[] ResolveAll<T>(string key = "", ILifetimeScope scope = null) { if (scope == null) { //no scope specified scope = Scope(); } if (string.IsNullOrEmpty(key)) { return scope.Resolve<IEnumerable<T>>().ToArray(); } return scope.ResolveKeyed<IEnumerable<T>>(key).ToArray(); } /// <summary> /// Resolve unregistered service /// </summary> /// <typeparam name="T">Type</typeparam> /// <param name="scope">Scope; pass null to automatically resolve the current scope</param> /// <returns>Resolved service</returns> public virtual T ResolveUnregistered<T>(ILifetimeScope scope = null) where T : class { return ResolveUnregistered(typeof(T), scope) as T; } /// <summary> /// Resolve unregistered service /// </summary> /// <param name="type">Type</param> /// <param name="scope">Scope; pass null to automatically resolve the current scope</param> /// <returns>Resolved service</returns> public virtual object ResolveUnregistered(Type type, ILifetimeScope scope = null) { if (scope == null) { //no scope specified scope = Scope(); } var constructors = type.GetConstructors(); foreach (var constructor in constructors) { try { var parameters = constructor.GetParameters(); var parameterInstances = new List<object>(); foreach (var parameter in parameters) { var service = Resolve(parameter.ParameterType, scope); if (service == null) throw new Exception("Unknown dependency"); parameterInstances.Add(service); } return Activator.CreateInstance(type, parameterInstances.ToArray()); } catch (Exception) { // ignored } } throw new Exception("No constructor was found that had all the dependencies satisfied."); } /// <summary> /// Try to resolve srevice /// </summary> /// <param name="serviceType">Type</param> /// <param name="scope">Scope; pass null to automatically resolve the current scope</param> /// <param name="instance">Resolved service</param> /// <returns>Value indicating whether service has been successfully resolved</returns> public virtual bool TryResolve(Type serviceType, ILifetimeScope scope, out object instance) { if (scope == null) { //no scope specified scope = Scope(); } return scope.TryResolve(serviceType, out instance); } /// <summary> /// Check whether some service is registered (can be resolved) /// </summary> /// <param name="serviceType">Type</param> /// <param name="scope">Scope; pass null to automatically resolve the current scope</param> /// <returns>Result</returns> public virtual bool IsRegistered(Type serviceType, ILifetimeScope scope = null) { if (scope == null) { //no scope specified scope = Scope(); } return scope.IsRegistered(serviceType); } /// <summary> /// Resolve optional /// </summary> /// <param name="serviceType">Type</param> /// <param name="scope">Scope; pass null to automatically resolve the current scope</param> /// <returns>Resolved service</returns> public virtual object ResolveOptional(Type serviceType, ILifetimeScope scope = null) { if (scope == null) { //no scope specified scope = Scope(); } return scope.ResolveOptional(serviceType); } /// <summary> /// Get current scope /// </summary> /// <returns>Scope</returns> public virtual ILifetimeScope Scope() { try { if (HttpContext.Current != null) return AutofacDependencyResolver.Current.RequestLifetimeScope; //when such lifetime scope is returned, you should be sure that it'll be disposed once used (e.g. in schedule tasks) return Container.BeginLifetimeScope(MatchingScopeLifetimeTags.RequestLifetimeScopeTag); } catch (Exception) { //we can get an exception here if RequestLifetimeScope is already disposed //for example, requested in or after "Application_EndRequest" handler //but note that usually it should never happen //when such lifetime scope is returned, you should be sure that it'll be disposed once used (e.g. in schedule tasks) return Container.BeginLifetimeScope(MatchingScopeLifetimeTags.RequestLifetimeScopeTag); } } }
2.IDependencyRegistrar----注入的接口实现控制器等等都需要继承这个接口
/// <summary> /// Dependency registrar interface /// </summary> public interface IDependencyRegistrar { /// <summary> /// Register services and interfaces /// </summary> /// <param name="builder">Container builder</param> /// <param name="typeFinder">Type finder</param> void Register(ContainerBuilder builder, ITypeFinder typeFinder); /// <summary> /// Order of this dependency registrar implementation /// </summary> int Order { get; } }
3.AppDomainTypeFinder----这个循环匹配所有匹配的程序集，项目名称不可以匹配其中的关键字 不然注入不了，自定义生成的程序集也可以添加到匹配列表里
public class AppDomainTypeFinder : ITypeFinder { #region Fields private bool ignoreReflectionErrors = true; private bool loadAppDomainAssemblies = true; private string assemblySkipLoadingPattern = "^System|^mscorlib|^Microsoft|^AjaxControlToolkit|^Antlr3|^Autofac|^AutoMapper|^Castle|^ComponentArt|^CppCodeProvider|^DotNetOpenAuth|^EntityFramework|^EPPlus|^FluentValidation|^ImageResizer|^itextsharp|^log4net|^MaxMind|^MbUnit|^MiniProfiler|^Mono.Math|^MvcContrib|^Newtonsoft|^NHibernate|^nunit|^Org.Mentalis|^PerlRegex|^QuickGraph|^Recaptcha|^Remotion|^RestSharp|^Rhino|^Telerik|^Iesi|^TestDriven|^TestFu|^UserAgentStringLibrary|^VJSharpCodeProvider|^WebActivator|^WebDev|^WebGrease"; private string assemblyRestrictToLoadingPattern = ".*"; private IList<string> assemblyNames = new List<string>(); #endregion #region Properties /// <summary>要查找的应用程序域</summary> public virtual AppDomain App { get { return AppDomain.CurrentDomain; } } /// <summary>获取或设置在加载类型时是否应该迭代应用程序域中的程序集。 加载模式在加载这些组件时应用。</summary> public bool LoadAppDomainAssemblies { get { return loadAppDomainAssemblies; } set { loadAppDomainAssemblies = value; } } /// <summary>除了在AppDomain中加载的组件之外，获取或设置组件加载的启动。</summary> public IList<string> AssemblyNames { get { return assemblyNames; } set { assemblyNames = value; } } /// <summary>获取我们知道不需要调查的dll的模式.</summary> public string AssemblySkipLoadingPattern { get { return assemblySkipLoadingPattern; } set { assemblySkipLoadingPattern = value; } } /// <summary>Gets or sets the pattern for dll that will be investigated. For ease of use this defaults to match all but to increase performance you might want to configure a pattern that includes assemblies and your own.</summary> /// <remarks>If you change this so that Nop assemblies arn't investigated (e.g. by not including something like "^Nop|..." you may break core functionality.</remarks> public string AssemblyRestrictToLoadingPattern { get { return assemblyRestrictToLoadingPattern; } set { assemblyRestrictToLoadingPattern = value; } } #endregion #region Methods public IEnumerable<Type> FindClassesOfType<T>(bool onlyConcreteClasses = true) { return FindClassesOfType(typeof(T), onlyConcreteClasses); } public IEnumerable<Type> FindClassesOfType(Type assignTypeFrom, bool onlyConcreteClasses = true) { return FindClassesOfType(assignTypeFrom, GetAssemblies(), onlyConcreteClasses); } public IEnumerable<Type> FindClassesOfType<T>(IEnumerable<Assembly> assemblies, bool onlyConcreteClasses = true) { return FindClassesOfType(typeof(T), assemblies, onlyConcreteClasses); } public IEnumerable<Type> FindClassesOfType(Type assignTypeFrom, IEnumerable<Assembly> assemblies, bool onlyConcreteClasses = true) { var result = new List<Type>(); try { foreach (var a in assemblies) { Type[] types = null; try { types = a.GetTypes(); } catch { //Entity Framework 6 doesn't allow getting types (throws an exception) if (!ignoreReflectionErrors) { throw; } } if (types != null) { foreach (var t in types) { if (assignTypeFrom.IsAssignableFrom(t) || (assignTypeFrom.IsGenericTypeDefinition && DoesTypeImplementOpenGeneric(t, assignTypeFrom))) { if (!t.IsInterface) { if (onlyConcreteClasses) { if (t.IsClass && !t.IsAbstract) { result.Add(t); } } else { result.Add(t); } } } } } } } catch (ReflectionTypeLoadException ex) { var msg = string.Empty; foreach (var e in ex.LoaderExceptions) msg += e.Message + Environment.NewLine; var fail = new Exception(msg, ex); Debug.WriteLine(fail.Message, fail); throw fail; } return result; } /// <summary>Gets the assemblies related to the current implementation.</summary> /// <returns>A list of assemblies that should be loaded by the Nop factory.</returns> public virtual IList<Assembly> GetAssemblies() { var addedAssemblyNames = new List<string>(); var assemblies = new List<Assembly>(); if (LoadAppDomainAssemblies) AddAssembliesInAppDomain(addedAssemblyNames, assemblies); AddConfiguredAssemblies(addedAssemblyNames, assemblies); return assemblies; } #endregion #region Utilities /// <summary> /// Iterates all assemblies in the AppDomain and if it's name matches the configured patterns add it to our list. /// </summary> /// <param name="addedAssemblyNames"></param> /// <param name="assemblies"></param> private void AddAssembliesInAppDomain(List<string> addedAssemblyNames, List<Assembly> assemblies) { foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) { if (Matches(assembly.FullName)) { if (!addedAssemblyNames.Contains(assembly.FullName)) { assemblies.Add(assembly); addedAssemblyNames.Add(assembly.FullName); } } } } /// <summary> /// Adds specifically configured assemblies. /// </summary> /// <param name="addedAssemblyNames"></param> /// <param name="assemblies"></param> protected virtual void AddConfiguredAssemblies(List<string> addedAssemblyNames, List<Assembly> assemblies) { foreach (string assemblyName in AssemblyNames) { Assembly assembly = Assembly.Load(assemblyName); if (!addedAssemblyNames.Contains(assembly.FullName)) { assemblies.Add(assembly); addedAssemblyNames.Add(assembly.FullName); } } } /// <summary> /// Check if a dll is one of the shipped dlls that we know don't need to be investigated. /// </summary> /// <param name="assemblyFullName"> /// The name of the assembly to check. /// </param> /// <returns> /// True if the assembly should be loaded into BotanicSystem. /// </returns> public virtual bool Matches(string assemblyFullName) { return !Matches(assemblyFullName, AssemblySkipLoadingPattern) && Matches(assemblyFullName, AssemblyRestrictToLoadingPattern); } /// <summary> /// Check if a dll is one of the shipped dlls that we know don't need to be investigated. /// </summary> /// <param name="assemblyFullName"> /// The assembly name to match. /// </param> /// <param name="pattern"> /// The regular expression pattern to match against the assembly name. /// </param> /// <returns> /// True if the pattern matches the assembly name. /// </returns> protected virtual bool Matches(string assemblyFullName, string pattern) { return Regex.IsMatch(assemblyFullName, pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled); } /// <summary> /// Makes sure matching assemblies in the supplied folder are loaded in the app domain. /// </summary> /// <param name="directoryPath"> /// The physical path to a directory containing dlls to load in the app domain. /// </param> protected virtual void LoadMatchingAssemblies(string directoryPath) { var loadedAssemblyNames = new List<string>(); foreach (Assembly a in GetAssemblies()) { loadedAssemblyNames.Add(a.FullName); } if (!Directory.Exists(directoryPath)) { return; } foreach (string dllPath in Directory.GetFiles(directoryPath, "*.dll")) { try { var an = AssemblyName.GetAssemblyName(dllPath); if (Matches(an.FullName) && !loadedAssemblyNames.Contains(an.FullName)) { App.Load(an); } //old loading stuff //Assembly a = Assembly.ReflectionOnlyLoadFrom(dllPath); //if (Matches(a.FullName) && !loadedAssemblyNames.Contains(a.FullName)) //{ // App.Load(a.FullName); //} } catch (BadImageFormatException ex) { Trace.TraceError(ex.ToString()); } } } /// <summary> /// Does type implement generic? /// </summary> /// <param name="type"></param> /// <param name="openGeneric"></param> /// <returns></returns> protected virtual bool DoesTypeImplementOpenGeneric(Type type, Type openGeneric) { try { var genericTypeDefinition = openGeneric.GetGenericTypeDefinition(); foreach (var implementedInterface in type.FindInterfaces((objType, objCriteria) => true, null)) { if (!implementedInterface.IsGenericType) continue; var isMatch = genericTypeDefinition.IsAssignableFrom(implementedInterface.GetGenericTypeDefinition()); return isMatch; } return false; } catch { return false; } } #endregion }
4.Engine 注入操作在这儿
/// <summary> /// Engine /// </summary> public class Engine : IEngine { #region Fields private ContainerManager _containerManager; #endregion #region Utilities /// <summary> /// Run startup tasks /// </summary> protected virtual void RunStartupTasks() { } /// <summary> /// Register dependencies /// </summary> /// <param name="config">Config</param> protected virtual void RegisterDependencies() { var builder = new ContainerBuilder(); var container = builder.Build(); this._containerManager = new ContainerManager(container); //we create new instance of ContainerBuilder //because Build() or Update() method can only be called once on a ContainerBuilder. //dependencies var typeFinder = new WebAppTypeFinder(); builder = new ContainerBuilder(); builder.RegisterInstance(this).As<IEngine>().SingleInstance(); builder.RegisterInstance(typeFinder).As<ITypeFinder>().SingleInstance(); builder.Update(container); //register dependencies provided by other assemblies builder = new ContainerBuilder(); var drTypes = typeFinder.FindClassesOfType<IDependencyRegistrar>(); var drInstances = new List<IDependencyRegistrar>(); foreach (var drType in drTypes) drInstances.Add((IDependencyRegistrar)Activator.CreateInstance(drType)); //sort drInstances = drInstances.AsQueryable().OrderBy(t => t.Order).ToList(); foreach (var dependencyRegistrar in drInstances) dependencyRegistrar.Register(builder, typeFinder); builder.Update(container); //set dependency resolver DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); } #endregion #region Methods /// <summary> /// Initialize components and plugins in the nop environment. /// </summary> public void Initialize() { //register dependencies RegisterDependencies(); } /// <summary> /// Resolve dependency /// </summary> /// <typeparam name="T">T</typeparam> /// <returns></returns> public T Resolve<T>() where T : class { return ContainerManager.Resolve<T>(); } /// <summary> /// Resolve dependency /// </summary> /// <param name="type">Type</param> /// <returns></returns> public object Resolve(Type type) { return ContainerManager.Resolve(type); } /// <summary> /// Resolve dependencies /// </summary> /// <typeparam name="T">T</typeparam> /// <returns></returns> public T[] ResolveAll<T>() { return ContainerManager.ResolveAll<T>(); } #endregion #region Properties /// <summary> /// Container manager /// </summary> public ContainerManager ContainerManager { get { return _containerManager; } } #endregion }
5.EngineContext
public class EngineContext { #region Methods /// <summary> /// 初始化静态实例 /// </summary> /// <param name="forceRecreate">创建新的工厂实例</param> [MethodImpl(MethodImplOptions.Synchronized)] public static IEngine Initialize(bool forceRecreate) { if (Singleton<IEngine>.Instance == null || forceRecreate) { Singleton<IEngine>.Instance = new Engine(); Singleton<IEngine>.Instance.Initialize(); } return Singleton<IEngine>.Instance; } /// <summary> /// 替换引擎 实现自己的引擎 /// </summary> /// <param name="engine"></param> /// <remarks></remarks> public static void Replace(IEngine engine) { Singleton<IEngine>.Instance = engine; } #endregion #region Properties /// <summary> /// 使用单例模式获取引擎，这样可以不用在构造函数中构造 /// </summary> public static IEngine Current { get { if (Singleton<IEngine>.Instance == null) { Initialize(false); } return Singleton<IEngine>.Instance; } } #endregion }
6.IEngine
public interface IEngine { /// <summary> /// Container manager /// </summary> ContainerManager ContainerManager { get; } /// <summary> /// Initialize components in the environment. /// </summary> void Initialize(); /// <summary> /// Resolve dependency /// </summary> /// <typeparam name="T">T</typeparam> /// <returns></returns> T Resolve<T>() where T : class; /// <summary> /// Resolve dependency /// </summary> /// <param name="type">Type</param> /// <returns></returns> object Resolve(Type type); /// <summary> /// Resolve dependencies /// </summary> /// <typeparam name="T">T</typeparam> /// <returns></returns> T[] ResolveAll<T>(); }
7.ITypeFinder
public interface ITypeFinder { IList<Assembly> GetAssemblies(); IEnumerable<Type> FindClassesOfType(Type assignTypeFrom, bool onlyConcreteClasses = true); IEnumerable<Type> FindClassesOfType(Type assignTypeFrom, IEnumerable<Assembly> assemblies, bool onlyConcreteClasses = true); IEnumerable<Type> FindClassesOfType<T>(bool onlyConcreteClasses = true); IEnumerable<Type> FindClassesOfType<T>(IEnumerable<Assembly> assemblies, bool onlyConcreteClasses = true); }
8.Singleton
/// <summary> /// 一个标准化的方法来存储单个实例 /// </summary> /// <typeparam name="T"></typeparam> /// <remarks></remarks> public class Singleton<T> : Singleton { static T instance; public static T Instance { get { return instance; } set { instance = value; AllSingletons[typeof(T)] = value; } } } /// <summary> /// 提供某种类型的单例列表。 /// </summary> /// <typeparam name="T"></typeparam> public class SingletonList<T> : Singleton<IList<T>> { static SingletonList() { Singleton<IList<T>>.Instance = new List<T>(); } /// <summary>对于指定类型T的单例实例。对于每种类型的T只有一个该列表的实例在该时间。</summary> public new static IList<T> Instance { get { return Singleton<IList<T>>.Instance; } } } /// <summary> /// 提供某个键值对类型的单例字典。 /// </summary> /// <typeparam name="TKey"></typeparam> /// <typeparam name="TValue"></typeparam> public class SingletonDictionary<TKey, TValue> : Singleton<IDictionary<TKey, TValue>> { static SingletonDictionary() { Singleton<Dictionary<TKey, TValue>>.Instance = new Dictionary<TKey, TValue>(); } public new static IDictionary<TKey, TValue> Instance { get { return Singleton<Dictionary<TKey, TValue>>.Instance; } } } /// <summary> /// 提供对存储的所有“单例”的访问 <see cref="Singleton{T}"/>. /// </summary> public class Singleton { static Singleton() { allSingletons = new Dictionary<Type, object>(); } static readonly IDictionary<Type, object> allSingletons; public static IDictionary<Type, object> AllSingletons { get { return allSingletons; } } }
9.WebAppTypeFinder
public class WebAppTypeFinder : AppDomainTypeFinder { #region Fields private bool _ensureBinFolderAssembliesLoaded = true; private bool _binFolderAssembliesLoaded; #endregion #region Properties /// <summary> /// 获取或设置是否应特别检查Web应用程序的bin文件夹中的程序集是否在应用程序加载时加载。 /// 这在需要在应用程序重新加载后需要在AppDomain中加载插件的情况下需要。 /// </summary> public bool EnsureBinFolderAssembliesLoaded { get { return _ensureBinFolderAssembliesLoaded; } set { _ensureBinFolderAssembliesLoaded = value; } } #endregion #region Methods /// <summary> ///获取bin的物理路径 /// </summary> /// <returns></returns> public virtual string GetBinDirectory() { if (HostingEnvironment.IsHosted) { //hosted return HttpRuntime.BinDirectory; } //not hosted. For example, run either in unit tests return AppDomain.CurrentDomain.BaseDirectory; } public override IList<Assembly> GetAssemblies() { if (this.EnsureBinFolderAssembliesLoaded && !_binFolderAssembliesLoaded) { _binFolderAssembliesLoaded = true; string binPath = GetBinDirectory(); //binPath = _webHelper.MapPath("~/bin"); LoadMatchingAssemblies(binPath); } return base.GetAssemblies(); } #endregion }
-------------------------------------------------------------------------------------------------------------------
注入一些常用的，还有最重要的控制器
public class DependencyRegistrar : IDependencyRegistrar { public void Register(ContainerBuilder builder, ITypeFinder typeFinder) { builder.Register(c => c.Resolve<HttpContextBase>().Request) .As<HttpRequestBase>() .InstancePerLifetimeScope(); builder.Register(c => c.Resolve<HttpContextBase>().Response) .As<HttpResponseBase>() .InstancePerLifetimeScope(); builder.Register(c => c.Resolve<HttpContextBase>().Server) .As<HttpServerUtilityBase>() .InstancePerLifetimeScope(); builder.Register(c => c.Resolve<HttpContextBase>().Session) .As<HttpSessionStateBase>() .InstancePerLifetimeScope(); //controllers builder.RegisterControllers(typeFinder.GetAssemblies().ToArray()); } /// <summary> /// Order of this dependency registrar implementation /// </summary> public int Order { get { return 0; } } }
-------------------------------------------------------------------------------------------------------------------
Global.asax.cs
protected void Application_Start() { EngineContext.Initialize(false); AreaRegistration.RegisterAllAreas(); RouteConfig.RegisterRoutes(RouteTable.Routes); }
-------------------------------------------------------------------------------------------------------------------
使用
1. var logger = EngineContext.Current.Resolve<ILogger>()
2.HomeController
#region private readonly ICalabashService _calabashService; #endregion public HomeController(ICalabashService calabashService) { _calabashService = calabashService; } public ActionResult Calabash() { return Content(_calabashService.Calabash()); }
over