在ASP.NET Web API里使用Autofac

通过NuGet安装Autofac.WebApi。（Nuget会安装依赖的Autofac.dll)。

PM > Install-Package Autofac.WebApi

引用如下命名空间。

using Autofac; 
using Autofac.Integration.WebApi;

 

 

using System;
using System.Collections.Generic;
using System.Linq;
using Autofac;
using System.Web.Mvc;
using Autofac.Integration.Mvc;
using Autofac.Integration.WebApi;
using System.Reflection;
using System.IO;
using System.Web.Http;

namespace WS.Base.AutoFac
{
    public class Ioc
    {
        public static ContainerBuilder builder = new ContainerBuilder();
        public static IContainer container;
        public static bool IsWebApplication = true;
        public static bool IsWebApi = true;
        static Ioc ioc = new Ioc();
        public static Ioc Instance
        {
            get
            {
                return ioc;
            }
        }

        #region GetServiceByLifetimeScope
        
        public static TR GetServiceByLifetimeScopeFunc<T1, TR>(Func<T1, TR> Fun)
        {
            TR r;
            using (var s = container.BeginLifetimeScope())
            {
                r = Fun(s.Resolve<T1>());
            }
            return r;
        }
        public static void GetServiceByLifetimeScope<T1>(Action<T1> Fun)
        {

            using (var s = container.BeginLifetimeScope())
            {
                Fun(s.Resolve<T1>());
            }
        }
        public static void GetServiceByLifetimeScope<T1, T2>(Action<T1, T2> Fun)
        {

            using (var s = container.BeginLifetimeScope())
            {
                Fun(s.Resolve<T1>(), s.Resolve<T2>());
            }
        }
        public static void GetServiceByLifetimeScope<T1, T2, T3>(Action<T1, T2, T3> Fun)
        {

            using (var s = container.BeginLifetimeScope())
            {
                Fun(s.Resolve<T1>(), s.Resolve<T2>(), s.Resolve<T3>());
            }
        }
        public static void GetServiceByLifetimeScope<T1, T2, T3, T4>(Action<T1, T2, T3, T4> Fun)
        {

            using (var s = container.BeginLifetimeScope())
            {
                Fun(s.Resolve<T1>(), s.Resolve<T2>(), s.Resolve<T3>(), s.Resolve<T4>());
            }
        }

        #endregion

        /// <summary>
        /// 自动注入当前程序集及引用程序集
        /// </summary>
        public static void AutoInjectCurrAssemblyAndReference(List<string> other = null)
        {
            if (IsWebApplication)
                webAappInject(Assembly.GetCallingAssembly(), other);
            else
                WinAappInject(Assembly.GetCallingAssembly(), other);

            Build();

        }
        static void webAappInject(Assembly mainAss, List<string> other = null)
        {
            if (other != null)
            {
                var pluginBinFolder = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory + "bin\\").GetFiles("*.dll");
                foreach (var dllfile in pluginBinFolder)
                {
                    if (other.Contains(dllfile.Name))
                    {
                        var asm = Assembly.LoadFrom(dllfile.FullName);
                        RegisterControllers(asm);
                        RegisterAssemblyByIDependency(asm);
                        RegisterAssemblyByAttribute(asm);
                        using (var dd = new StreamWriter(AppDomain.CurrentDomain.BaseDirectory + "注入日志.txt", true))
                        {

                            dd.WriteLine(asm.FullName);
                        }
                    }
                }
            }

        }
        static void WinAappInject(Assembly mainAss, List<string> other = null)
        {

            var AssemblyList = mainAss.GetReferencedAssemblies();

            foreach (var item in AssemblyList)
            {
                var a = Assembly.Load(item);
                RegisterControllers(a);
                RegisterAssemblyByIDependency(a);
                RegisterAssemblyByAttribute(a);
                using (var dd = new StreamWriter(System.AppDomain.CurrentDomain.BaseDirectory + "注入日志.txt", true))
                {

                    dd.WriteLine(a.FullName);
                }

            }
            if (other != null)
            {

                var pluginBinFolder = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory).GetFiles("*.dll");
                foreach (var dllfile in pluginBinFolder)
                {
                    if (other.Contains(dllfile.Name))
                    {
                        var asm = Assembly.LoadFrom(dllfile.FullName);
                        RegisterAssemblyByIDependency(asm);
                        RegisterAssemblyByAttribute(asm);
                        using (var dd = new StreamWriter(AppDomain.CurrentDomain.BaseDirectory + "注入日志.txt", true))
                        {

                            dd.WriteLine(asm.FullName);
                        }
                    }
                }
            };
            RegisterAssemblyByIDependency(mainAss);
            RegisterAssemblyByAttribute(mainAss);
        }

        public static void Build()
        {
            RegisterAssemblyByIDependency(Assembly.GetExecutingAssembly());
            RegisterAssemblyByAttribute(Assembly.GetExecutingAssembly());
            container = builder.Build();
            if (IsWebApplication)
            {

                DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

                HttpConfiguration config = GlobalConfiguration.Configuration;
                config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            }
        }
        public static T GetService<T>()
        {



            if (IsWebApplication)
                return DependencyResolver.Current.GetService<T>();
            else
                return container.Resolve<T>();

        }

        /// <summary>
        /// 控制器类注入
        /// </summary>
        /// <param name="assembly"></param>
        public static void RegisterControllers(Assembly assembly)
        {
            builder.RegisterControllers(assembly);
            builder.RegisterApiControllers(assembly);
        }

        /// <summary>
        /// 接口类注入 根据IDependency
        /// </summary>
        /// <param name="assembly"></param>
        public static void RegisterAssemblyByIDependency(Assembly assembly)
        {
            var baseType = typeof(IDependency);
            if (IsWebApplication)
                builder.RegisterAssemblyTypes(assembly).
                    Where(t => baseType.IsAssignableFrom(t) && t != baseType).
                    AsImplementedInterfaces().InstancePerRequest();
            else
                builder.RegisterAssemblyTypes(assembly).
                    Where(t => baseType.IsAssignableFrom(t) && t != baseType).
                    AsImplementedInterfaces().InstancePerLifetimeScope();

        }

        /// <summary>
        /// 属性类注入 根据 DependencyAttribute
        /// </summary>
        /// <param name="assembly"></param>
        public static void RegisterAssemblyByAttribute(Assembly assembly)
        {
            var allClass = from types in assembly.GetExportedTypes()
                           where types.IsClass
                           select types;
            foreach (var c in allClass)
            {
                var exportAttrs = c.GetCustomAttributes(typeof(DependencyAttribute), false);
                if (exportAttrs.Length > 0)
                {
                    var exportAttr = exportAttrs[0] as DependencyAttribute;
                    if (null != exportAttr.ContractKey)
                    {
                        if (exportAttr.SingleInstance)
                            builder.RegisterType(c).Keyed(exportAttr.ContractKey, exportAttr.ContractType).SingleInstance();
                        else
                            builder.RegisterType(c).Keyed(exportAttr.ContractKey, exportAttr.ContractType).InstancePerRequest();
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(exportAttr.ContractName))
                        {
                            if (exportAttr.SingleInstance)
                                builder.RegisterType(c).Named(exportAttr.ContractName, exportAttr.ContractType).SingleInstance();
                            else
                                builder.RegisterType(c).Named(exportAttr.ContractName, exportAttr.ContractType).InstancePerRequest();
                        }
                        else
                        {
                            if (null != exportAttr.ContractType)
                            {
                                if (exportAttr.SingleInstance)
                                    builder.RegisterType(c).As(exportAttr.ContractType).SingleInstance();
                                else
                                    builder.RegisterType(c).As(exportAttr.ContractType).InstancePerRequest();
                            }
                            else
                            {
                                if (exportAttr.SingleInstance)
                                    builder.RegisterType(c).SingleInstance();
                                else
                                {
                                    if (IsWebApplication)
                                    {
                                        builder.RegisterType(c).InstancePerRequest();
                                    }
                                    else
                                    {
                                        builder.RegisterType(c).InstancePerLifetimeScope();
                                    }
                                }


                            }
                        }
                    }
                }
            }

        }



    }
}