程序集准备

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

  1.     /// <summary>
  2.     /// Container manager
  3.     /// </summary>
  4.     public class ContainerManager
  5.     {
  6.         private readonly IContainer _container;
  7.  
  8.         /// <summary>
  9.         /// Constructor
  10.         /// </summary>
  11.         /// <param name="container">Conainer</param>
  12.         public ContainerManager(IContainer container)
  13.         {
  14.             this._container = container;
  15.         }
  16.  
  17.         /// <summary>
  18.         /// Gets a container
  19.         /// </summary>
  20.         public virtual IContainer Container
  21.         {
  22.             get
  23.             {
  24.                 return _container;
  25.             }
  26.         }
  27.  
  28.         /// <summary>
  29.         /// Resolve
  30.         /// </summary>
  31.         /// <typeparam name="T">Type</typeparam>
  32.         /// <param name="key">key</param>
  33.         /// <param name="scope">Scope; pass null to automatically resolve the current scope</param>
  34.         /// <returns>Resolved service</returns>
  35.         public virtual T Resolve<T>(string key = "", ILifetimeScope scope = null) where T : class
  36.         {
  37.             if (scope == null)
  38.             {
  39.                 //no scope specified
  40.                 scope = Scope();
  41.             }
  42.             if (string.IsNullOrEmpty(key))
  43.             {
  44.                 return scope.Resolve<T>();
  45.             }
  46.             return scope.ResolveKeyed<T>(key);
  47.         }
  48.  
  49.         /// <summary>
  50.         /// Resolve
  51.         /// </summary>
  52.         /// <param name="type">Type</param>
  53.         /// <param name="scope">Scope; pass null to automatically resolve the current scope</param>
  54.         /// <returns>Resolved service</returns>
  55.         public virtual object Resolve(Type type, ILifetimeScope scope = null)
  56.         {
  57.             if (scope == null)
  58.             {
  59.                 //no scope specified
  60.                 scope = Scope();
  61.             }
  62.             return scope.Resolve(type);
  63.         }
  64.  
  65.         /// <summary>
  66.         /// Resolve all
  67.         /// </summary>
  68.         /// <typeparam name="T">Type</typeparam>
  69.         /// <param name="key">key</param>
  70.         /// <param name="scope">Scope; pass null to automatically resolve the current scope</param>
  71.         /// <returns>Resolved services</returns>
  72.         public virtual T[] ResolveAll<T>(string key = "", ILifetimeScope scope = null)
  73.         {
  74.             if (scope == null)
  75.             {
  76.                 //no scope specified
  77.                 scope = Scope();
  78.             }
  79.             if (string.IsNullOrEmpty(key))
  80.             {
  81.                 return scope.Resolve<IEnumerable<T>>().ToArray();
  82.             }
  83.             return scope.ResolveKeyed<IEnumerable<T>>(key).ToArray();
  84.         }
  85.  
  86.         /// <summary>
  87.         /// Resolve unregistered service
  88.         /// </summary>
  89.         /// <typeparam name="T">Type</typeparam>
  90.         /// <param name="scope">Scope; pass null to automatically resolve the current scope</param>
  91.         /// <returns>Resolved service</returns>
  92.         public virtual T ResolveUnregistered<T>(ILifetimeScope scope = null) where T : class
  93.         {
  94.             return ResolveUnregistered(typeof(T), scope) as T;
  95.         }
  96.  
  97.         /// <summary>
  98.         /// Resolve unregistered service
  99.         /// </summary>
  100.         /// <param name="type">Type</param>
  101.         /// <param name="scope">Scope; pass null to automatically resolve the current scope</param>
  102.         /// <returns>Resolved service</returns>
  103.         public virtual object ResolveUnregistered(Type type, ILifetimeScope scope = null)
  104.         {
  105.             if (scope == null)
  106.             {
  107.                 //no scope specified
  108.                 scope = Scope();
  109.             }
  110.             var constructors = type.GetConstructors();
  111.             foreach (var constructor in constructors)
  112.             {
  113.                 try
  114.                 {
  115.                     var parameters = constructor.GetParameters();
  116.                     var parameterInstances = new List<object>();
  117.                     foreach (var parameter in parameters)
  118.                     {
  119.                         var service = Resolve(parameter.ParameterType, scope);
  120.                         if (service == null) throw new Exception("Unknown dependency");
  121.                         parameterInstances.Add(service);
  122.                     }
  123.                     return Activator.CreateInstance(type, parameterInstances.ToArray());
  124.                 }
  125.                 catch (Exception)
  126.                 {
  127.                     // ignored
  128.                 }
  129.             }
  130.             throw new Exception("No constructor  was found that had all the dependencies satisfied.");
  131.         }
  132.  
  133.         /// <summary>
  134.         /// Try to resolve srevice
  135.         /// </summary>
  136.         /// <param name="serviceType">Type</param>
  137.         /// <param name="scope">Scope; pass null to automatically resolve the current scope</param>
  138.         /// <param name="instance">Resolved service</param>
  139.         /// <returns>Value indicating whether service has been successfully resolved</returns>
  140.         public virtual bool TryResolve(Type serviceType, ILifetimeScope scope, out object instance)
  141.         {
  142.             if (scope == null)
  143.             {
  144.                 //no scope specified
  145.                 scope = Scope();
  146.             }
  147.             return scope.TryResolve(serviceType, out instance);
  148.         }
  149.  
  150.         /// <summary>
  151.         /// Check whether some service is registered (can be resolved)
  152.         /// </summary>
  153.         /// <param name="serviceType">Type</param>
  154.         /// <param name="scope">Scope; pass null to automatically resolve the current scope</param>
  155.         /// <returns>Result</returns>
  156.         public virtual bool IsRegistered(Type serviceType, ILifetimeScope scope = null)
  157.         {
  158.             if (scope == null)
  159.             {
  160.                 //no scope specified
  161.                 scope = Scope();
  162.             }
  163.             return scope.IsRegistered(serviceType);
  164.         }
  165.  
  166.         /// <summary>
  167.         /// Resolve optional
  168.         /// </summary>
  169.         /// <param name="serviceType">Type</param>
  170.         /// <param name="scope">Scope; pass null to automatically resolve the current scope</param>
  171.         /// <returns>Resolved service</returns>
  172.         public virtual object ResolveOptional(Type serviceType, ILifetimeScope scope = null)
  173.         {
  174.             if (scope == null)
  175.             {
  176.                 //no scope specified
  177.                 scope = Scope();
  178.             }
  179.             return scope.ResolveOptional(serviceType);
  180.         }
  181.  
  182.         /// <summary>
  183.         /// Get current scope
  184.         /// </summary>
  185.         /// <returns>Scope</returns>
  186.         public virtual ILifetimeScope Scope()
  187.         {
  188.             try
  189.             {
  190.                 if (HttpContext.Current != null)
  191.                     return AutofacDependencyResolver.Current.RequestLifetimeScope;
  192.  
  193.                 //when such lifetime scope is returned, you should be sure that it'll be disposed once used (e.g. in schedule tasks)
  194.                 return Container.BeginLifetimeScope(MatchingScopeLifetimeTags.RequestLifetimeScopeTag);
  195.             }
  196.             catch (Exception)
  197.             {
  198.                 //we can get an exception here if RequestLifetimeScope is already disposed
  199.                 //for example, requested in or after "Application_EndRequest" handler
  200.                 //but note that usually it should never happen
  201.  
  202.                 //when such lifetime scope is returned, you should be sure that it'll be disposed once used (e.g. in schedule tasks)
  203.                 return Container.BeginLifetimeScope(MatchingScopeLifetimeTags.RequestLifetimeScopeTag);
  204.             }
  205.         }
  206.     }

2.IDependencyRegistrar----注入的接口实现控制器等等都需要继承这个接口

  1.     /// <summary>
  2.     /// Dependency registrar interface
  3.     /// </summary>
  4.     public interface IDependencyRegistrar
  5.     {
  6.         /// <summary>
  7.         /// Register services and interfaces
  8.         /// </summary>
  9.         /// <param name="builder">Container builder</param>
  10.         /// <param name="typeFinder">Type finder</param>
  11.         void Register(ContainerBuilder builder, ITypeFinder typeFinder);
  12.  
  13.         /// <summary>
  14.         /// Order of this dependency registrar implementation
  15.         /// </summary>
  16.         int Order { get; }
  17.     }

3.AppDomainTypeFinder----这个循环匹配所有匹配的程序集，项目名称不可以匹配其中的关键字 不然注入不了，自定义生成的程序集也可以添加到匹配列表里

  1.     public class AppDomainTypeFinder : ITypeFinder
  2.     {
  3.         #region Fields
  4.  
  5.         private bool ignoreReflectionErrors = true;
  6.         private bool loadAppDomainAssemblies = true;
  7.         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";
  8.         private string assemblyRestrictToLoadingPattern = ".*";
  9.         private IList<string> assemblyNames = new List<string>();
  10.  
  11.         #endregion
  12.  
  13.         #region Properties
  14.  
  15.         /// <summary>要查找的应用程序域</summary>
  16.         public virtual AppDomain App
  17.         {
  18.             get { return AppDomain.CurrentDomain; }
  19.         }
  20.  
  21.         /// <summary>获取或设置在加载类型时是否应该迭代应用程序域中的程序集。 加载模式在加载这些组件时应用。</summary>
  22.         public bool LoadAppDomainAssemblies
  23.         {
  24.             get { return loadAppDomainAssemblies; }
  25.             set { loadAppDomainAssemblies = value; }
  26.         }
  27.  
  28.         /// <summary>除了在AppDomain中加载的组件之外，获取或设置组件加载的启动。</summary>
  29.         public IList<string> AssemblyNames
  30.         {
  31.             get { return assemblyNames; }
  32.             set { assemblyNames = value; }
  33.         }
  34.  
  35.         /// <summary>获取我们知道不需要调查的dll的模式.</summary>
  36.         public string AssemblySkipLoadingPattern
  37.         {
  38.             get { return assemblySkipLoadingPattern; }
  39.             set { assemblySkipLoadingPattern = value; }
  40.         }
  41.  
  42.         /// <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>
  43.         /// <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>
  44.         public string AssemblyRestrictToLoadingPattern
  45.         {
  46.             get { return assemblyRestrictToLoadingPattern; }
  47.             set { assemblyRestrictToLoadingPattern = value; }
  48.         }
  49.  
  50.         #endregion
  51.  
  52.         #region Methods
  53.  
  54.         public IEnumerable<Type> FindClassesOfType<T>(bool onlyConcreteClasses = true)
  55.         {
  56.             return FindClassesOfType(typeof(T), onlyConcreteClasses);
  57.         }
  58.  
  59.         public IEnumerable<Type> FindClassesOfType(Type assignTypeFrom, bool onlyConcreteClasses = true)
  60.         {
  61.             return FindClassesOfType(assignTypeFrom, GetAssemblies(), onlyConcreteClasses);
  62.         }
  63.  
  64.         public IEnumerable<Type> FindClassesOfType<T>(IEnumerable<Assembly> assemblies, bool onlyConcreteClasses = true)
  65.         {
  66.             return FindClassesOfType(typeof(T), assemblies, onlyConcreteClasses);
  67.         }
  68.  
  69.         public IEnumerable<Type> FindClassesOfType(Type assignTypeFrom, IEnumerable<Assembly> assemblies, bool onlyConcreteClasses = true)
  70.         {
  71.             var result = new List<Type>();
  72.             try
  73.             {
  74.                 foreach (var a in assemblies)
  75.                 {
  76.                     Type[] types = null;
  77.                     try
  78.                     {
  79.                         types = a.GetTypes();
  80.                     }
  81.                     catch
  82.                     {
  83.                         //Entity Framework 6 doesn't allow getting types (throws an exception)
  84.                         if (!ignoreReflectionErrors)
  85.                         {
  86.                             throw;
  87.                         }
  88.                     }
  89.                     if (types != null)
  90.                     {
  91.                         foreach (var t in types)
  92.                         {
  93.                             if (assignTypeFrom.IsAssignableFrom(t) || (assignTypeFrom.IsGenericTypeDefinition && DoesTypeImplementOpenGeneric(t, assignTypeFrom)))
  94.                             {
  95.                                 if (!t.IsInterface)
  96.                                 {
  97.                                     if (onlyConcreteClasses)
  98.                                     {
  99.                                         if (t.IsClass && !t.IsAbstract)
  100.                                         {
  101.                                             result.Add(t);
  102.                                         }
  103.                                     }
  104.                                     else
  105.                                     {
  106.                                         result.Add(t);
  107.                                     }
  108.                                 }
  109.                             }
  110.                         }
  111.                     }
  112.                 }
  113.             }
  114.             catch (ReflectionTypeLoadException ex)
  115.             {
  116.                 var msg = string.Empty;
  117.                 foreach (var e in ex.LoaderExceptions)
  118.                     msg += e.Message + Environment.NewLine;
  119.  
  120.                 var fail = new Exception(msg, ex);
  121.                 Debug.WriteLine(fail.Message, fail);
  122.  
  123.                 throw fail;
  124.             }
  125.             return result;
  126.         }
  127.  
  128.         /// <summary>Gets the assemblies related to the current implementation.</summary>
  129.         /// <returns>A list of assemblies that should be loaded by the Nop factory.</returns>
  130.         public virtual IList<Assembly> GetAssemblies()
  131.         {
  132.             var addedAssemblyNames = new List<string>();
  133.             var assemblies = new List<Assembly>();
  134.  
  135.             if (LoadAppDomainAssemblies)
  136.                 AddAssembliesInAppDomain(addedAssemblyNames, assemblies);
  137.             AddConfiguredAssemblies(addedAssemblyNames, assemblies);
  138.  
  139.             return assemblies;
  140.         }
  141.  
  142.         #endregion
  143.  
  144.         #region Utilities
  145.  
  146.         /// <summary>
  147.         /// Iterates all assemblies in the AppDomain and if it's name matches the configured patterns add it to our list.
  148.         /// </summary>
  149.         /// <param name="addedAssemblyNames"></param>
  150.         /// <param name="assemblies"></param>
  151.         private void AddAssembliesInAppDomain(List<string> addedAssemblyNames, List<Assembly> assemblies)
  152.         {
  153.             foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
  154.             {
  155.                 if (Matches(assembly.FullName))
  156.                 {
  157.                     if (!addedAssemblyNames.Contains(assembly.FullName))
  158.                     {
  159.                         assemblies.Add(assembly);
  160.                         addedAssemblyNames.Add(assembly.FullName);
  161.                     }
  162.                 }
  163.             }
  164.         }
  165.  
  166.         /// <summary>
  167.         /// Adds specifically configured assemblies.
  168.         /// </summary>
  169.         /// <param name="addedAssemblyNames"></param>
  170.         /// <param name="assemblies"></param>
  171.         protected virtual void AddConfiguredAssemblies(List<string> addedAssemblyNames, List<Assembly> assemblies)
  172.         {
  173.             foreach (string assemblyName in AssemblyNames)
  174.             {
  175.                 Assembly assembly = Assembly.Load(assemblyName);
  176.                 if (!addedAssemblyNames.Contains(assembly.FullName))
  177.                 {
  178.                     assemblies.Add(assembly);
  179.                     addedAssemblyNames.Add(assembly.FullName);
  180.                 }
  181.             }
  182.         }
  183.  
  184.         /// <summary>
  185.         /// Check if a dll is one of the shipped dlls that we know don't need to be investigated.
  186.         /// </summary>
  187.         /// <param name="assemblyFullName">
  188.         /// The name of the assembly to check.
  189.         /// </param>
  190.         /// <returns>
  191.         /// True if the assembly should be loaded into BotanicSystem.
  192.         /// </returns>
  193.         public virtual bool Matches(string assemblyFullName)
  194.         {
  195.             return !Matches(assemblyFullName, AssemblySkipLoadingPattern)
  196.                    && Matches(assemblyFullName, AssemblyRestrictToLoadingPattern);
  197.         }
  198.  
  199.         /// <summary>
  200.         /// Check if a dll is one of the shipped dlls that we know don't need to be investigated.
  201.         /// </summary>
  202.         /// <param name="assemblyFullName">
  203.         /// The assembly name to match.
  204.         /// </param>
  205.         /// <param name="pattern">
  206.         /// The regular expression pattern to match against the assembly name.
  207.         /// </param>
  208.         /// <returns>
  209.         /// True if the pattern matches the assembly name.
  210.         /// </returns>
  211.         protected virtual bool Matches(string assemblyFullName, string pattern)
  212.         {
  213.             return Regex.IsMatch(assemblyFullName, pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
  214.         }
  215.  
  216.         /// <summary>
  217.         /// Makes sure matching assemblies in the supplied folder are loaded in the app domain.
  218.         /// </summary>
  219.         /// <param name="directoryPath">
  220.         /// The physical path to a directory containing dlls to load in the app domain.
  221.         /// </param>
  222.         protected virtual void LoadMatchingAssemblies(string directoryPath)
  223.         {
  224.             var loadedAssemblyNames = new List<string>();
  225.             foreach (Assembly a in GetAssemblies())
  226.             {
  227.                 loadedAssemblyNames.Add(a.FullName);
  228.             }
  229.  
  230.             if (!Directory.Exists(directoryPath))
  231.             {
  232.                 return;
  233.             }
  234.  
  235.             foreach (string dllPath in Directory.GetFiles(directoryPath, "*.dll"))
  236.             {
  237.                 try
  238.                 {
  239.                     var an = AssemblyName.GetAssemblyName(dllPath);
  240.                     if (Matches(an.FullName) && !loadedAssemblyNames.Contains(an.FullName))
  241.                     {
  242.                         App.Load(an);
  243.                     }
  244.  
  245.                     //old loading stuff
  246.                     //Assembly a = Assembly.ReflectionOnlyLoadFrom(dllPath);
  247.                     //if (Matches(a.FullName) && !loadedAssemblyNames.Contains(a.FullName))
  248.                     //{
  249.                     //    App.Load(a.FullName);
  250.                     //}
  251.                 }
  252.                 catch (BadImageFormatException ex)
  253.                 {
  254.                     Trace.TraceError(ex.ToString());
  255.                 }
  256.             }
  257.         }
  258.  
  259.         /// <summary>
  260.         /// Does type implement generic?
  261.         /// </summary>
  262.         /// <param name="type"></param>
  263.         /// <param name="openGeneric"></param>
  264.         /// <returns></returns>
  265.         protected virtual bool DoesTypeImplementOpenGeneric(Type type, Type openGeneric)
  266.         {
  267.             try
  268.             {
  269.                 var genericTypeDefinition = openGeneric.GetGenericTypeDefinition();
  270.                 foreach (var implementedInterface in type.FindInterfaces((objType, objCriteria) => true, null))
  271.                 {
  272.                     if (!implementedInterface.IsGenericType)
  273.                         continue;
  274.  
  275.                     var isMatch = genericTypeDefinition.IsAssignableFrom(implementedInterface.GetGenericTypeDefinition());
  276.                     return isMatch;
  277.                 }
  278.                 return false;
  279.             }
  280.             catch
  281.             {
  282.                 return false;
  283.             }
  284.         }
  285.  
  286.         #endregion
  287.     }

4.Engine 注入操作在这儿

  1.     /// <summary>
  2.     /// Engine
  3.     /// </summary>
  4.     public class Engine : IEngine
  5.     {
  6.         #region Fields
  7.  
  8.         private ContainerManager _containerManager;
  9.  
  10.         #endregion
  11.  
  12.         #region Utilities
  13.  
  14.         /// <summary>
  15.         /// Run startup tasks
  16.         /// </summary>
  17.         protected virtual void RunStartupTasks()
  18.         {
  19.         }
  20.  
  21.         /// <summary>
  22.         /// Register dependencies
  23.         /// </summary>
  24.         /// <param name="config">Config</param>
  25.         protected virtual void RegisterDependencies()
  26.         {
  27.             var builder = new ContainerBuilder();
  28.             var container = builder.Build();
  29.             this._containerManager = new ContainerManager(container);
  30.  
  31.             //we create new instance of ContainerBuilder
  32.             //because Build() or Update() method can only be called once on a ContainerBuilder.
  33.  
  34.             //dependencies
  35.             var typeFinder = new WebAppTypeFinder();
  36.             builder = new ContainerBuilder();
  37.             builder.RegisterInstance(this).As<IEngine>().SingleInstance();
  38.             builder.RegisterInstance(typeFinder).As<ITypeFinder>().SingleInstance();
  39.             builder.Update(container);
  40.  
  41.             //register dependencies provided by other assemblies
  42.             builder = new ContainerBuilder();
  43.             var drTypes = typeFinder.FindClassesOfType<IDependencyRegistrar>();
  44.             var drInstances = new List<IDependencyRegistrar>();
  45.             foreach (var drType in drTypes)
  46.                 drInstances.Add((IDependencyRegistrar)Activator.CreateInstance(drType));
  47.             //sort
  48.             drInstances = drInstances.AsQueryable().OrderBy(t => t.Order).ToList();
  49.             foreach (var dependencyRegistrar in drInstances)
  50.                 dependencyRegistrar.Register(builder, typeFinder);
  51.             builder.Update(container);
  52.  
  53.             //set dependency resolver
  54.             DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
  55.         }
  56.  
  57.         #endregion
  58.  
  59.         #region Methods
  60.  
  61.         /// <summary>
  62.         /// Initialize components and plugins in the nop environment.
  63.         /// </summary>
  64.         public void Initialize()
  65.         {
  66.             //register dependencies
  67.             RegisterDependencies();
  68.         }
  69.  
  70.         /// <summary>
  71.         /// Resolve dependency
  72.         /// </summary>
  73.         /// <typeparam name="T">T</typeparam>
  74.         /// <returns></returns>
  75.         public T Resolve<T>() where T : class
  76.         {
  77.             return ContainerManager.Resolve<T>();
  78.         }
  79.  
  80.         /// <summary>
  81.         ///  Resolve dependency
  82.         /// </summary>
  83.         /// <param name="type">Type</param>
  84.         /// <returns></returns>
  85.         public object Resolve(Type type)
  86.         {
  87.             return ContainerManager.Resolve(type);
  88.         }
  89.  
  90.         /// <summary>
  91.         /// Resolve dependencies
  92.         /// </summary>
  93.         /// <typeparam name="T">T</typeparam>
  94.         /// <returns></returns>
  95.         public T[] ResolveAll<T>()
  96.         {
  97.             return ContainerManager.ResolveAll<T>();
  98.         }
  99.  
  100.         #endregion
  101.  
  102.         #region Properties
  103.  
  104.         /// <summary>
  105.         /// Container manager
  106.         /// </summary>
  107.         public ContainerManager ContainerManager
  108.         {
  109.             get { return _containerManager; }
  110.         }
  111.  
  112.         #endregion
  113.     }

5.EngineContext

  1.     public class EngineContext
  2.     {
  3.         #region Methods
  4.  
  5.         /// <summary>
  6.         /// 初始化静态实例
  7.         /// </summary>
  8.         /// <param name="forceRecreate">创建新的工厂实例</param>
  9.         [MethodImpl(MethodImplOptions.Synchronized)]
  10.         public static IEngine Initialize(bool forceRecreate)
  11.         {
  12.             if (Singleton<IEngine>.Instance == null || forceRecreate)
  13.             {
  14.                 Singleton<IEngine>.Instance = new Engine();
  15.                 Singleton<IEngine>.Instance.Initialize();
  16.             }
  17.             return Singleton<IEngine>.Instance;
  18.         }
  19.  
  20.         /// <summary>
  21.         /// 替换引擎 实现自己的引擎
  22.         /// </summary>
  23.         /// <param name="engine"></param>
  24.         /// <remarks></remarks>
  25.         public static void Replace(IEngine engine)
  26.         {
  27.             Singleton<IEngine>.Instance = engine;
  28.         }
  29.  
  30.         #endregion
  31.  
  32.         #region Properties
  33.  
  34.         /// <summary>
  35.         /// 使用单例模式获取引擎，这样可以不用在构造函数中构造
  36.         /// </summary>
  37.         public static IEngine Current
  38.         {
  39.             get
  40.             {
  41.                 if (Singleton<IEngine>.Instance == null)
  42.                 {
  43.                     Initialize(false);
  44.                 }
  45.                 return Singleton<IEngine>.Instance;
  46.             }
  47.         }
  48.  
  49.         #endregion
  50.     }

6.IEngine

  1.     public interface IEngine
  2.     {
  3.         /// <summary>
  4.         /// Container manager
  5.         /// </summary>
  6.         ContainerManager ContainerManager { get; }
  7.  
  8.         /// <summary>
  9.         /// Initialize components  in the environment.
  10.         /// </summary>
  11.         void Initialize();
  12.  
  13.         /// <summary>
  14.         /// Resolve dependency
  15.         /// </summary>
  16.         /// <typeparam name="T">T</typeparam>
  17.         /// <returns></returns>
  18.         T Resolve<T>() where T : class;
  19.  
  20.         /// <summary>
  21.         ///  Resolve dependency
  22.         /// </summary>
  23.         /// <param name="type">Type</param>
  24.         /// <returns></returns>
  25.         object Resolve(Type type);
  26.  
  27.         /// <summary>
  28.         /// Resolve dependencies
  29.         /// </summary>
  30.         /// <typeparam name="T">T</typeparam>
  31.         /// <returns></returns>
  32.         T[] ResolveAll<T>();
  33.     }

7.ITypeFinder

  1.     public interface ITypeFinder
  2.     {
  3.         IList<Assembly> GetAssemblies();
  4.  
  5.         IEnumerable<Type> FindClassesOfType(Type assignTypeFrom, bool onlyConcreteClasses = true);
  6.  
  7.         IEnumerable<Type> FindClassesOfType(Type assignTypeFrom, IEnumerable<Assembly> assemblies, bool onlyConcreteClasses = true);
  8.  
  9.         IEnumerable<Type> FindClassesOfType<T>(bool onlyConcreteClasses = true);
  10.  
  11.         IEnumerable<Type> FindClassesOfType<T>(IEnumerable<Assembly> assemblies, bool onlyConcreteClasses = true);
  12.     }

8.Singleton

  1.     /// <summary>
  2.     /// 一个标准化的方法来存储单个实例
  3.     /// </summary>
  4.     /// <typeparam name="T"></typeparam>
  5.     /// <remarks></remarks>
  6.     public class Singleton<T> : Singleton
  7.     {
  8.         static T instance;
  9.         public static T Instance
  10.         {
  11.             get { return instance; }
  12.             set
  13.             {
  14.                 instance = value;
  15.                 AllSingletons[typeof(T)] = value;
  16.             }
  17.         }
  18.     }
  19.  
  20.     /// <summary>
  21.     /// 提供某种类型的单例列表。
  22.     /// </summary>
  23.     /// <typeparam name="T"></typeparam>
  24.     public class SingletonList<T> : Singleton<IList<T>>
  25.     {
  26.         static SingletonList()
  27.         {
  28.             Singleton<IList<T>>.Instance = new List<T>();
  29.         }
  30.  
  31.         /// <summary>对于指定类型T的单例实例。对于每种类型的T只有一个该列表的实例在该时间。</summary>
  32.         public new static IList<T> Instance
  33.         {
  34.             get { return Singleton<IList<T>>.Instance; }
  35.         }
  36.     }
  37.  
  38.     /// <summary>
  39.     /// 提供某个键值对类型的单例字典。
  40.     /// </summary>
  41.     /// <typeparam name="TKey"></typeparam>
  42.     /// <typeparam name="TValue"></typeparam>
  43.     public class SingletonDictionary<TKey, TValue> : Singleton<IDictionary<TKey, TValue>>
  44.     {
  45.         static SingletonDictionary()
  46.         {
  47.             Singleton<Dictionary<TKey, TValue>>.Instance = new Dictionary<TKey, TValue>();
  48.         }
  49.  
  50.         public new static IDictionary<TKey, TValue> Instance
  51.         {
  52.             get { return Singleton<Dictionary<TKey, TValue>>.Instance; }
  53.         }
  54.     }
  55.  
  56.     /// <summary>
  57.     /// 提供对存储的所有“单例”的访问 <see cref="Singleton{T}"/>.
  58.     /// </summary>
  59.     public class Singleton
  60.     {
  61.         static Singleton()
  62.         {
  63.             allSingletons = new Dictionary<Type, object>();
  64.         }
  65.  
  66.         static readonly IDictionary<Type, object> allSingletons;
  67.  
  68.         public static IDictionary<Type, object> AllSingletons
  69.         {
  70.             get { return allSingletons; }
  71.         }
  72.     }

9.WebAppTypeFinder

  1.     public class WebAppTypeFinder : AppDomainTypeFinder
  2.     {
  3.         #region Fields
  4.  
  5.         private bool _ensureBinFolderAssembliesLoaded = true;
  6.         private bool _binFolderAssembliesLoaded;
  7.  
  8.         #endregion
  9.  
  10.         #region Properties
  11.  
  12.         /// <summary>
  13.         /// 获取或设置是否应特别检查Web应用程序的bin文件夹中的程序集是否在应用程序加载时加载。
  14.         /// 这在需要在应用程序重新加载后需要在AppDomain中加载插件的情况下需要。
  15.         /// </summary>
  16.         public bool EnsureBinFolderAssembliesLoaded
  17.         {
  18.             get { return _ensureBinFolderAssembliesLoaded; }
  19.             set { _ensureBinFolderAssembliesLoaded = value; }
  20.         }
  21.  
  22.         #endregion
  23.  
  24.         #region Methods
  25.  
  26.         /// <summary>
  27.         ///获取bin的物理路径
  28.         /// </summary>
  29.         /// <returns></returns>
  30.         public virtual string GetBinDirectory()
  31.         {
  32.             if (HostingEnvironment.IsHosted)
  33.             {
  34.                 //hosted
  35.                 return HttpRuntime.BinDirectory;
  36.             }
  37.  
  38.             //not hosted. For example, run either in unit tests
  39.             return AppDomain.CurrentDomain.BaseDirectory;
  40.         }
  41.  
  42.         public override IList<Assembly> GetAssemblies()
  43.         {
  44.             if (this.EnsureBinFolderAssembliesLoaded && !_binFolderAssembliesLoaded)
  45.             {
  46.                 _binFolderAssembliesLoaded = true;
  47.                 string binPath = GetBinDirectory();
  48.                 //binPath = _webHelper.MapPath("~/bin");
  49.                 LoadMatchingAssemblies(binPath);
  50.             }
  51.  
  52.             return base.GetAssemblies();
  53.         }
  54.  
  55.         #endregion
  56.     }

-------------------------------------------------------------------------------------------------------------------

注入一些常用的，还有最重要的控制器

  1.     public class DependencyRegistrar : IDependencyRegistrar
  2.     {
  3.         public void Register(ContainerBuilder builder, ITypeFinder typeFinder)
  4.         {
  5.             builder.Register(c => c.Resolve<HttpContextBase>().Request)
  6.                 .As<HttpRequestBase>()
  7.                 .InstancePerLifetimeScope();
  8.             builder.Register(c => c.Resolve<HttpContextBase>().Response)
  9.                 .As<HttpResponseBase>()
  10.                 .InstancePerLifetimeScope();
  11.             builder.Register(c => c.Resolve<HttpContextBase>().Server)
  12.                 .As<HttpServerUtilityBase>()
  13.                 .InstancePerLifetimeScope();
  14.             builder.Register(c => c.Resolve<HttpContextBase>().Session)
  15.                 .As<HttpSessionStateBase>()
  16.                 .InstancePerLifetimeScope();
  17.  
  18.             //controllers
  19.             builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());
  20.         }
  21.  
  22.         /// <summary>
  23.         /// Order of this dependency registrar implementation
  24.         /// </summary>
  25.         public int Order
  26.         {
  27.             get { return ; }
  28.         }
  29.     }

-------------------------------------------------------------------------------------------------------------------

Global.asax.cs

  1.         protected void Application_Start()
  2.         {
  3.             EngineContext.Initialize(false);
  4.             AreaRegistration.RegisterAllAreas();
  5.             RouteConfig.RegisterRoutes(RouteTable.Routes);
  6.         }

-------------------------------------------------------------------------------------------------------------------

使用

1. var logger =  EngineContext.Current.Resolve<ILogger>()

2.HomeController

  1.         #region
  2.  
  3.         private readonly ICalabashService _calabashService;
  4.         #endregion
  5.  
  6.         public HomeController(ICalabashService calabashService)
  7.         {
  8.             _calabashService = calabashService;
  9.         }
  10.  
  11.         public ActionResult Calabash()
  12.         {
  13.             return Content(_calabashService.Calabash());
  14.         }

over

Autofac的更多相关文章

  1. AutoFac在项目中的应用

    技能大全:http://www.cnblogs.com/dunitian/p/4822808.html#skill 完整Demo:https://github.com/dunitian/LoTCode ...

  2. Autofac - MVC/WebApi中的应用

    Autofac前面写了那么多篇, 其实就是为了今天这一篇, Autofac在MVC和WebApi中的应用. 一.目录结构 先看一下我的目录结构吧, 搭了个非常简单的架构, IOC(web), IBLL ...

  3. Autofac - 生命周期

    实例生命周期决定在同一个服务的每个请求的实例是如何共享的. 当请求一个服务的时候,Autofac会返回一个单例 (single instance作用域), 一个新的对象 (per lifetime作用 ...

  4. Autofac - 属性注入

    属性注入不同于通过构造函数方式传入参数. 这里是通过注入的方式, 在类创建完毕之后, 资源释放之前, 给属性赋值. 这里, 我重新弄一些类来演示这一篇吧. public class ClassA { ...

  5. Autofac 的点滴

    泛型类型的注册和使用 public interface IRepository<T> where T:class { } public interface ISchoolDetailRep ...

  6. ASP.NET Core 整合Autofac和Castle实现自动AOP拦截

    前言: 除了ASP.NETCore自带的IOC容器外,我们还可以使用其他成熟的DI框架,如Autofac,StructureMap等(笔者只用过Unity,Ninject和Castle). 1.ASP ...

  7. Autofac 的属性注入，IOC的坑

    Autofac 是一款优秀的IOC的开源工具,完美的适配.Net特性,但是有时候我们想通过属性注入的方式来获取我们注入的对象,对不起,有时候你还真是获取不到,这因为什么呢? 1.你对Autofac 不 ...

  8. Autofac 组件、服务、自动装配 《第二篇》

    一.组件 创建出来的对象需要从组件中来获取,组件的创建有如下4种(延续第一篇的Demo,仅仅变动所贴出的代码)方式: 1.类型创建RegisterType AutoFac能够通过反射检查一个类型,选择 ...

  9. 使用Adminlite + ASP.NET MVC5(C#) + Entityframework + AutoFac + AutoMapper写了个api接口文档管理系统

    一.演示: 接口查看:http://apidoc.docode.top/ 接口后台:http://apiadmin.docode.top/ 登录:administrator,123456 二.使用到的 ...

  10. autofac 组件的实例范围

    实例范围决定如何在请求之间共享服务. 原文地址:http://docs.autofac.org/en/latest/lifetime/instance-scope.html 每个依赖一个实例 使用这个 ...

随机推荐

  1. table 相关

    border-collapse: collapse; 合并多余边框

  2. 【GoLang】golang 闭包 closure 参数传递的蹊跷！

    结论: 闭包函数可以直接引用外层代码定义的变量, 但是,注意,闭包函数里面引用的是变量的地址, 当goroutine被调度时,改地址的值才会被传递给goroutine 函数. 介绍 go的闭包是一个很 ...

  3. HTML CSS SPRITE 工具

    推荐一个CSS SPRITE工具 网盘分享:http://pan.baidu.com/s/1sjx7cZV

  4. yii框架中验证器声明一组内置验证器可以使用短名称引用

    1.内置验证器的短名称分别有: boolean: yii\validators\BooleanValidator captcha: yii\captcha\CaptchaValidator compa ...

  5. yii 常用的多表查询

    return $this->model()->getDbConnection()->createCommand() ->select("t.type,t.title, ...

  6. 使用Fiddler搭建手机调试环境（我做得项目是调试微信的公众号）

    部分内容参考:http://ju.outofmemory.cn/entry/22854 我们在测试微信企业号的时候,由于微信的限制,不能把它拿到chrome浏览器中进行调试,所以就不能实时的看到页面变 ...

  7. PHP中删除数组空值的方法

    array_filter函数的功能是利用回调函数来对数组进行过滤,如果没有回调函数,那么默认就是删除数组中值为false的项目. 例如 $entry = array(                0 ...

  8. [工作中的设计模式]迭代子模式Iterator

    一.模式解析 迭代子模式又叫游标(Cursor)模式,是对象的行为模式.迭代子模式可以顺序地访问一个聚集中的元素而不必暴露聚集的内部表象 1.迭代子模式一般用于对集合框架的访问,常用的集合框架为lis ...

  9. ViewPager打造轮播图（Banner）\引导页（Guide）

    今年7月时,在Github发布了一个开源的Banner库,虽然Star不多,但还是有少部分人使用. Banner效果:  昨天,有使用此库的同学提出需求,想在引导页的时候用这个库并且最后一页有进入按钮 ...

  10. Win7下完全卸载Oracle 11g

    1 右击“计算机”-->管理-->服务和应用程序-->服务,停掉所有Oracle相关的服务(以Oracle打头的,比如OracleDBConsoleorcl). 2 开始--> ...