.Net Core 2.0 集成 Autofac（构造函数注入 + 属性注入 + 多态注入）

一、创建.Net Core Web Mvc项目

二、

Nuget引入Autofac的包：
Install-Package Autofac
Install-Package Autofac.Extensions.DependencyInjection

 

三、编写Autofac注册服务类：

1.AutofacHelper

using System.Reflection;

namespace WebAutofac
{
    public class AutofacHelper
    {
        /// <summary>
        /// 根据程序集名称，获取到程序集
        /// </summary>
        /// <param name="assemblyName"></param>
        /// <returns></returns>
        public static Assembly GetAssemblyByName(string assemblyName)
        {
            var s = Assembly.GetExecutingAssembly();
            var r = Assembly.Load(assemblyName);
            var u = typeof(Startup).Assembly;
            DataModel.Logs.Add($"Assembly.GetExecutingAssembly() == Assembly.Load({assemblyName}) => {s == r}");
            DataModel.Logs.Add($"Assembly.GetExecutingAssembly() == typeof(Startup).Assembly => {s == u}");
            DataModel.Logs.Add($"Assembly.Load({assemblyName}) == typeof(Startup).Assembly => {r == u}");
            return r;
        }
    }
}

2.ServiceModule（注入服务）：

using Autofac;

namespace WebAutofac
{
    public class ServiceModule : Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            //注入程序集下面的所有以Service结尾的，并且不是接口的类，注入到所实现的接口中
            builder.RegisterAssemblyTypes(AutofacHelper.GetAssemblyByName("WebAutofac"))
                .Where(a => a.Name.EndsWith("Service") && a.IsInterface == false).AsImplementedInterfaces()
                .PropertiesAutowired().SingleInstance();
            //三种注入方式：
            //单例：SingleInstance
            //相当于New：InstancePerDependency
            //每一次请求共用一个：InstancePerLifetimeScope

            RegisterMultipleImplement(builder);
        }

        /// <summary>
        /// 一个接口，多个实现注入（推荐使用Keyed）
        /// </summary>
        /// <param name="builder"></param>
        private static void RegisterMultipleImplement(ContainerBuilder builder)
        {
            //builder.RegisterType<DeptApproveService>().Named<IApproveService>(ApproveTypeEnum.Dept.ToString());
            //builder.RegisterType<BossApproveService>().Named<IApproveService>(ApproveTypeEnum.Boss.ToString());

            builder.RegisterType<DeptApproveService>().Keyed<IApproveService>(ApproveTypeEnum.Dept);
            builder.RegisterType<BossApproveService>().Keyed<IApproveService>(ApproveTypeEnum.Boss);
        }
    }
}

3.ControllerModule（注入控制器）：

using System;
using Autofac;
using Microsoft.AspNetCore.Mvc;

namespace WebAutofac
{
    /// <summary>
    /// 注入控制器（属性注入时使用）
    /// </summary>
    public class ControllerModule : Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            Type controllerType = typeof(Controller);
            builder.RegisterAssemblyTypes(AutofacHelper.GetAssemblyByName("WebAutofac")).Where(t => controllerType.IsAssignableFrom(t) && t != controllerType).PropertiesAutowired();
        }
    }
}

4.AutofacComponent（Autofac注入组件）：

using Autofac;
using Autofac.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using System;

namespace WebAutofac
{
    public class AutofacComponent
    {
        public static IServiceProvider Register(IServiceCollection services)
        {
            //实例化Autofac容器
            ContainerBuilder builder = new ContainerBuilder();
            //将collection中的服务填充到Autofac
            builder.Populate(services);
            //注册
            builder.RegisterModule<ControllerModule>();//注入控制器（属性注入时使用）
            builder.RegisterModule<ServiceModule>();
            //创建容器
            IContainer container = builder.Build();
            //第三方容器接管Core内置的DI容器
            return new AutofacServiceProvider(container);
        }
    }
}

 

到这里就可以了，我们来测试一下：

using System.Diagnostics;
using Autofac;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using WebAutofac.Models;

namespace WebAutofac.Controllers
{
    public class HomeController : Controller
    {
        private IApproveService _DeptApproveService;

        private IApproveService _BossApproveService;

        private IComponentContext _ComponentContext;

        public HomeController(IComponentContext componentContext)
        {
            //this._UserService = userService;
            this._ComponentContext = componentContext;
            this._DeptApproveService = _ComponentContext.ResolveKeyed<IApproveService>(ApproveTypeEnum.Dept);
            this._BossApproveService = _ComponentContext.ResolveKeyed<IApproveService>(ApproveTypeEnum.Boss);
        }

        public IUserService _UserService { get; set; }

        public IActionResult Index()
        {
            return View();
        }

        public IActionResult About()
        {
            //属性注入和构造函数注入可以同时使用
            var loginResult = _UserService.Login("user123", "123456");
            var deptApproveResult = _DeptApproveService.Approve("张三");
            var bossApproveResult = _BossApproveService.Approve("张三");
            ViewData["Message"] = JsonConvert.SerializeObject(new
            {
                LoginResult = loginResult,
                DeptApproveResult = deptApproveResult,
                BossApproveResult = bossApproveResult,
                Logs = DataModel.Logs
            });

            return View();
        }

        public IActionResult Contact()
        {
            ViewData["Message"] = "Your contact page.";

            return View();
        }

        public IActionResult Error()
        {
            return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
        }
    }
}

 

运行结果：

json格式化后：

 

至于还有带参构造函数，如何注入，我这里懒得写了，准备下班了

Ending~