1. 程式人生 > >【半小時大話.net依賴注入】(下)詳解AutoFac+實戰Mvc、Api以及.NET Core的依賴注入

【半小時大話.net依賴注入】(下)詳解AutoFac+實戰Mvc、Api以及.NET Core的依賴注入

系列目錄

  1. 第一章|理論基礎+實戰控制檯程式實現AutoFac注入

  2. 第二章|AutoFac的使用技巧

  3. 第三章|實戰Asp.Net Framework Web程式實現AutoFac注入

  4. 第四章|實戰Asp.Net Core自帶DI實現依賴注入

  5. 第五章|實戰Asp.Net Core引入AutoFac的兩種方式

前言

本來計劃是五篇文章的,但是第一篇發了之後,我發現.NET環境下很多人對IoC和DI都很排斥,搞得評論區異常熱鬧。
同一個東西,在Java下和在.NET下能有這麼大的差異,也是挺有意思的一件事情。

所以我就把剩下四篇內容精簡再精簡,合成一篇了,權當是寫給自己的一個備忘記錄了。
GitHub原始碼地址:https://github.com/WangRui321/Ray.EssayNotes.AutoFac

原始碼是一個虛構的專案框架,類似於樣例性質的程式碼或者測試程式,裡面很多註釋,對理解DI,或怎麼在MVC、WebApi和Core Api分別實現依賴注入有很好的幫助效果。
所以,以下內容,配合原始碼食用效果更佳~

第一部分:詳解AutoFac用法

名詞解釋

老規矩,理論先行。

元件(Components)

一串聲明瞭它所提供服務和它所消費依賴的程式碼。

可以理解為容器內的基本單元,一個容器內會被註冊很多個元件,每個元件都有自己的資訊:比如暴露的服務型別、生命週期域、繫結的具象物件等。

服務(Services)

一個在提供和消費元件之間明確定義的行為約定。

和專案中的xxxService不同,AutoFac的服務是對容器而言的,可以簡單的理解為上一章講的元件的暴露型別

(即對外開放的服務型別),也就是As方法裡的東西:

builder.RegisterType<CallLogger>()
       .As<ILogger>()
       .As<ICallInterceptor>();

這裡,針對同一個註冊物件(CallLogger),容器就對外暴露了兩個服務(service),ILogger服務和ICallInterceptor服務。

生命週期作用域(LifeTimeScope)

  • 生命週期

指服務例項在你的應用中存在的時長:從開始例項化到最後釋放結束。

  • 作用域

指它在應用中能共享給其他元件並被消費的作用域。例如, 應用中有個全域性的靜態單例,那麼該全域性物件例項的 "作用域" 將會是整個應用。

  • 生命週期作用域

其實是把這兩個概念組合在了一起, 可以理解為應用中的一個工作單元。後面詳細講。

怎麼理解它們的關係

容器是一個自動售貨機,元件是放在裡面的在售商品,服務是商品的出售名稱
把商品(專案裡的具象物件)放入自動售貨機(容器)上架的過程叫註冊
註冊的時候會給商品貼上標籤,標註該商品的名稱,這個名稱就叫服務
我們還可以標註這個商品的適用人群和過期時間等(生命週期作用域);
把這個包裝後的商品放入自動售貨機後,它就變成了在售商品(元件)。
當有顧客需要某個商品時,他只要對著售貨機報一個商品名(服務名),自動售貨機找到對應商品,丟擲給客戶,這個拋給你的過程,就叫做注入你;
而且這個售貨機比較智慧,丟擲前還可以先判斷商品是不是過期了,該不該拋給你。

註冊元件

即在容器初始化時,向容器內新增物件的操作。AutoFac封裝了以下幾種便捷的註冊方法:

反射註冊

直接指定注入物件與暴露型別,使用RegisterType<T>()或者RegisterType(typeof(T))方法:

builder.RegisterType<StudentRepository>()
    .As<IStudentRepository>();
builder.RegisterType(typeof(StudentService))
    .As(typeof(IStudentService));

例項註冊

將例項註冊到容器,使用RegisterInstance()方法,通常有兩種:

  • new出一個物件註冊:
var output = new StringWriter();
builder.RegisterInstance(output).As<TextWriter>();
  • 註冊專案已存在單例:
builder.RegisterInstance(MySingleton.Instance).ExternallyOwned();

Lambda表示式註冊

builder.Register(x => new StudentRepository())
    .As<IStudentRepository>();
builder.Register(x => new StudentService(x.Resolve<IStudentRepository>()))
    .As<IStudentService>();

利用拉姆達註冊可以實現一些常規反射無法實現的操作,比如一些複雜引數註冊。

泛型註冊

最常見的就是泛型倉儲的註冊:

builder.RegisterGeneric(typeof(BaseRepository<>))
    .As(typeof(IBaseRepository<>))
    .InstancePerLifetimeScope();

條件註冊

通過加上判斷條件,來決定是否執行該條註冊語句。

  • IfNotRegistered

表示:如果沒註冊過xxx,就執行語句:

builder.RegisterType<TeacherRepository>()
    .AsSelf()
    .IfNotRegistered(typeof(ITeacherRepository));

只有當ITeacherRepository服務型別沒有被註冊過,才會執行該條註冊語句。

  • OnlyIf

表示:只有...,才會執行語句:

builder.RegisterType<TeacherService>()
    .AsSelf()
    .As<ITeacherService>()
    .OnlyIf(x => 
            x.IsRegistered(new TypedService(typeof(ITeacherRepository)))||
            x.IsRegistered(new TypedService(typeof(TeacherRepository))));

只有當ITeacherRepository服務型別或者TeacherRepository服務型別被註冊過,才會執行該條註冊語句。

程式集批量註冊

最常用,也最實用的一個註冊方法,使用該方法最好要懂點反射的知識。

        /// <summary>
        /// 通過反射程式集批量註冊
        /// </summary>
        /// <param name="builder"></param>
        public static void BuildContainerFunc8(ContainerBuilder builder)
        {
            Assembly[] assemblies = Helpers.ReflectionHelper.GetAllAssemblies();

            builder.RegisterAssemblyTypes(assemblies)//程式集內所有具象類(concrete classes)
                .Where(cc =>cc.Name.EndsWith("Repository")|//篩選
                            cc.Name.EndsWith("Service"))
                .PublicOnly()//只要public訪問許可權的
                .Where(cc=>cc.IsClass)//只要class型(主要為了排除值和interface型別)
                //.Except<TeacherRepository>()//排除某型別
                //.As(x=>x.GetInterfaces()[0])//反射出其實現的介面,預設以第一個介面型別暴露
                .AsImplementedInterfaces();//自動以其實現的所有介面型別暴露(包括IDisposable介面)

            builder.RegisterGeneric(typeof(BaseRepository<>))
                .As(typeof(IBaseRepository<>));
        }

如上會批量註冊專案中所有的Repository和Service。

屬性注入

講屬性注入之前,要先看下構造注入。

  • 構造注入
    即解析的時候,利用建構函式注入,形式如下:
    /// <summary>
    /// 學生邏輯處理
    /// </summary>
    public class StudentService : IStudentService
    {
        private readonly IStudentRepository _studentRepository;
        /// <summary>
        /// 構造注入
        /// </summary>
        /// <param name="studentRepository"></param>
        public StudentService(IStudentRepository studentRepository)
        {
            _studentRepository = studentRepository;
        }
    }

在建構函式的引數中直接寫入服務型別,AutoFac解析該類時,就會去容器內部已存在的元件中查詢,然後將匹配的物件注入到建構函式中去。

  • 屬性注入
    屬性注入與構造注入不同,是將容器內對應的元件直接注入到類內的屬性中去,形式如下:
    /// <summary>
    /// 教師邏輯處理
    /// </summary>
    public class TeacherService : ITeacherService
    {
        /// <summary>
        /// 用於屬性注入
        /// </summary>
        public ITeacherRepository TeacherRepository { get; set; }

        public string GetTeacherName(long id)
        {
            return TeacherRepository?.Get(111).Name;
        }
    }

要使用這種屬性注入,在註冊該屬性所屬類的時候,需要使用PropertiesAutowired()方法額外標註,如下:

builder.RegisterType<TeacherService>().PropertiesAutowired();

這樣,容器在解析並例項化TeacherService類時,便會將容器內的元件與類內的屬性做對映,如果相同則自動將元件注入到類內屬性種。

  • 注意

屬性注入爭議性很大,很多人稱這是一種_反模式_,事實也確實如此。
使用屬性注入會讓程式碼可讀性變得極其複雜(而複雜難懂的程式碼一定不是好的程式碼,不管用的技術有多高大上)。
但是屬性注入也不是一無是處,因為屬性注入有一個特性:
在構造注入的時候,如果建構函式的引數中有一個物件在容器不存在,那麼解析就會報錯。
但是屬性注入就不一樣了,當容器內沒有與該屬性型別對應的元件時,這時解析不會報異常,只會讓這個屬性保持為空型別(null)。
利用這個特性,可以實現一些特殊的操作。

暴露服務

即上面提到的As<xxx>()函式,AutoFac提供了以下三種標註暴露服務型別的方法:

以其自身型別暴露服務

使用AsSelf()方法標識,表示以其自身型別暴露,也是當沒有標註暴露服務的時候的預設選項。
如下四種寫法是等效的:

builder.RegisterType<StudentService>();//不標註,預設以自身型別暴露服務
builder.RegisterType<StudentService>().AsSelf();
builder.RegisterType<StudentService>().As<StudentService>();
builder.RegisterType<StudentService>().As(typeof(StudentService));

以其實現的介面(interface)暴露服務

使用As()方法標識,暴露的型別可以是多個,比如CallLogger類實現了ILogger介面和ICallInterceptor介面,那麼可以這麼寫:

builder.RegisterType<CallLogger>()
       .As<ILogger>()
       .As<ICallInterceptor>()
       .AsSelf();

程式集批量註冊時指定暴露型別

  • 方法1:自己指定
        public static void BuildContainerFunc8(ContainerBuilder builder)
        {
            Assembly[] assemblies = Helpers.ReflectionHelper.GetAllAssemblies();

            builder.RegisterAssemblyTypes(assemblies)//程式集內所有具象類(concrete classes)
                .Where(cc =>cc.Name.EndsWith("Repository")|//篩選
                            cc.Name.EndsWith("Service"))
                .As(x=>x.GetInterfaces()[0])//反射出其實現的介面,並指定以其實現的第一個介面型別暴露
        }
  • 方法2:以其實現的所有介面型別暴露

使用AsImplementedInterfaces()函式實現,相當於一個類實現了幾個介面(interface)就會暴露出幾個服務,等價於上面連寫多個As()的作用。

        public static void BuildContainerFunc8(ContainerBuilder builder)
        {
            Assembly[] assemblies = Helpers.ReflectionHelper.GetAllAssemblies();

            builder.RegisterAssemblyTypes(assemblies)//程式集內所有具象類(concrete classes)
                .Where(cc =>cc.Name.EndsWith("Repository")|//篩選
                            cc.Name.EndsWith("Service"))
                .AsImplementedInterfaces();//自動以其實現的所有介面型別暴露(包括IDisposable介面)
        }

生命週期作用域

相當於UnitWork(工作單元)的概念。下面羅列出了AutoFac與.NET Core的生命週期作用域,並作了簡要的對比。

AutoFac的生命週期作用域

下面講下AutoFac定義的幾種生命週期作用域,上一篇評論裡也有人提了,關於生命週期作用域這塊確實不是很好理解,所以下面每中型別我都寫了一個例子程式,這些例子程式對理解很有幫助,只要能讀懂這些例子程式,就一定能弄懂這些生命週期作用域。(例子專案原始碼裡都有,可以去試著實際執行下,更易理解)

瞬時例項(Instance Per Dependency)

也叫每個依賴一個例項。
即每次從容器裡拿出來的都是全新物件,相當於每次都new出一個。
在其他容器中也被標識為 'Transient'(瞬時) 或 'Factory'(工廠)。

  • 註冊

使用InstancePerDependency()方法標註,如果不標註,這也是預設的選項。以下兩種註冊方法是等效的:

//不指定,預設就是瞬時的
builder.RegisterType<Model.StudentEntity>();

//指定其生命週期域為瞬時
builder.RegisterType<Model.StudentEntity>().InstancePerDependency();
  • 解析:
using (var scope = Container.Instance.BeginLifetimeScope())
{
    var stu1 = scope.Resolve<Model.StudentEntity>();
    Console.WriteLine($"第1次列印:{stu1.Name}");
    stu1.Name = "張三";
    Console.WriteLine($"第2次列印:{stu1.Name}");

    var stu2 = scope.Resolve<Model.StudentEntity>();
    Console.WriteLine($"第2次列印:{stu2.Name}");
}

上面解析了2次,有兩個例項,stu1和stu2指向不同的兩塊記憶體,彼此之間沒有關係。
列印結果:

單例(Single Instance)

即全域性只有一個例項,在根容器和所有巢狀作用域內,每次解析返回的都是同一個例項。

  • 註冊

使用SingleInstance()方法標識:

builder.RegisterType<Model.StudentEntity>().SingleInstance();
  • 解析:
//直接從根域內解析(單例下可以使用,其他不建議這樣直接從根域內解析)
var stu1 = Container.Instance.Resolve<Model.StudentEntity>();
stu1.Name = "張三";
Console.WriteLine($"第1次列印:{stu1.Name}");

using (var scope1 = Container.Instance.BeginLifetimeScope())
{
    var stu2 = scope1.Resolve<Model.StudentEntity>();
    Console.WriteLine($"第2次列印:{stu2.Name}");

    stu1.Name = "李四";
}
using (var scope2 = Container.Instance.BeginLifetimeScope())
{
    var stu3 = scope2.Resolve<Model.StudentEntity>();
    Console.WriteLine($"第3次列印:{stu3.Name}");
}

上面的stu1、stu2、stu3都是同一個例項,在記憶體上它們指向同一個記憶體塊。
列印結果:

域內單例(Instance Per Lifetime Scope)

即在每個生命週期域內是單例的。

  • 註冊
    使用InstancePerLifetimeScope()方法標識:
x.RegisterType<Model.StudentEntity>().InstancePerLifetimeScope();
  • 解析
//子域一
using (var scope1 = Container.Instance.BeginLifetimeScope())
{
    var stu1 = scope1.Resolve<Model.StudentEntity>();
    Console.WriteLine($"第1次列印:{stu1.Name}");
    
    stu1.Name = "張三";

    var stu2 = scope1.Resolve<Model.StudentEntity>();
    Console.WriteLine($"第2次列印:{stu2.Name}");
}
//子域二
using (var scope2 = Container.Instance.BeginLifetimeScope())
{
    var stuA = scope2.Resolve<Model.StudentEntity>();
    Console.WriteLine($"第3次列印:{stuA.Name}");
    
    stuA.Name = "李四";

    var stuB = scope2.Resolve<Model.StudentEntity>();
    Console.WriteLine($"第4次列印:{stuB.Name}");
}

如上,在子域一中,雖然解析了2次,但是2次解析出的都是同一個例項,即stu1和stu2指向同一個記憶體塊Ⅰ。
子域二也一樣,stuA和stuB指向同一個記憶體塊Ⅱ,但是記憶體塊Ⅰ和記憶體塊Ⅱ卻不是同一塊。
列印結果如下,第1次和第3次為null:

指定域內單例(Instance Per Matching Lifetime Scope)

即每個匹配的生命週期作用域一個例項。
該域型別其實是上面的“域內單例”的其中一種,不一樣的是它允許我們給域“打標籤”,只要在這個特定的標籤域內就是單例的。

  • 註冊
    使用InstancePerMatchingLifetimeScope(string tagName)方法註冊:
builder.RegisterType<Worker>().InstancePerMatchingLifetimeScope("myTag");
  • 解析
//myScope標籤子域一
using (var myScope1 = Container.Instance.BeginLifetimeScope("myTag"))
{
    var stu1 = myScope1.Resolve<Model.StudentEntity>();
    stu1.Name = "張三";
    Console.WriteLine($"第1次列印:{stu1.Name}");

    var stu2 = myScope1.Resolve<Model.StudentEntity>();
    Console.WriteLine($"第2次列印:{stu2.Name}");
    //解析了2次,但2次都是同一個例項(stu1和stu2指向同一個記憶體塊Ⅰ)
}
//myScope標籤子域二
using (var myScope2 = Container.Instance.BeginLifetimeScope("myTag"))
{
    var stuA = myScope2.Resolve<Model.StudentEntity>();
    Console.WriteLine($"第3次列印:{stuA.Name}");
    //因為標籤域內已註冊過,所以可以解析成功
    //但是因為和上面不是同一個子域,所以解析出的例項stuA與之前的並不是同一個例項,指向另一個記憶體塊Ⅱ
}
//無標籤子域三
using (var noTagScope = Container.Instance.BeginLifetimeScope())
{
    try
    {
        var stuOne = noTagScope.Resolve<Model.StudentEntity>();//會報異常
        Console.WriteLine($"第4次正常列印:{stuOne.Name}");
    }
    catch (Exception e)
    {
        Console.WriteLine($"第4次異常列印:{e.Message}");
    }
    //因為StudentEntity只被註冊到帶有myScope標籤域內,所以這裡解析不到,報異常
}

列印結果:

需要注意:

  • 第3次列印為null,不同子域即使標籤相同,但也是不同子域,所以域之間不是同一個例項
  • 在其他標籤的域內(包括無標籤域)解析,會報異常

每次請求內單例(Instance Per Request)

該種類型適用於“request”型別的應用,比如MVC和WebApi。
其實質其實又是上一種的“指定域內單例”的一種特殊情況:AutoFac內有一個字串常量叫Autofac.Core.Lifetime.MatchingScopeLifetimeTags.RequestLifetimeScopeTag,其值為"AutofacWebRequest",當“指定域內單例”打的標籤是這個常量時,那它就是“每次請求內單例”了。

  • 註冊
    使用InstancePerRequest()方法標註:
builder.RegisterType<Model.StudentEntity>().InstancePerRequest();

也可以使用上面的域內單例的註冊法(但是不建議):

//使用常量標記
builder.RegisterType<Model.StudentEntity>().InstancePerMatchingLifetimeScope(Autofac.Core.Lifetime.MatchingScopeLifetimeTags.RequestLifetimeScopeTag);
//或者直接寫明字串
builder.RegisterType<Model.StudentEntity>().InstancePerMatchingLifetimeScope("AutofacWebRequest");

這裡用控制檯程式不好舉例子就不寫解析程式碼了,要理解“每次請求內單例”的作用,最好的例子就是EF中的DBContext,我們在一次request請求內,即使是用到了多個Service和多個Repository,也只需要一個數據庫例項,這樣即能減少資料庫例項初始化的消耗,還能實現事務的功能。

.NET Core的生命週期作用域(Service lifetimes)

相比於AutoFac的豐富複雜,.NET Core就比較簡單粗暴了,只要3種類型:

瞬時例項(Transient)

與AutoFac的瞬時例項(Instance Per Dependency)相同,每次都是全新的例項。
使用AddTransient()註冊:

services.AddTransient<IStudentService, StudentService>();

請求內單例(Scoped)

其意義與AutoFac的請求內單例(Instance Per Request)相同,但實際如果真正在.NET Core中使用使用AutoFac的話,應該使用AutoFac的域內單例(Instance Per LifetimeScope)來代替。
原因是.NET Core框架自帶的DI(Microsoft.Extensions.DependencyInjection)全權接管了請求和生命週期作用域的建立,所以AutoFac無法控制,但是使用域內單例(Instance Per LifetimeScope)可以實現相同的效果。
使用AddScoped()註冊:

services.AddScoped<IStudentService, StudentService>();

單例(Singleton)

與AutoFac的單例(Single Instance)相同。
使用AddSingleton();註冊:

services.AddSingleton<StudentEntity>();

第二部分:.NET Framework Web程式AutoFac注入

MVC專案

MVC容器

除了AutoFac主包之外,還需要Nuget匯入AutoFac.Mvc5包:

容器程式碼:

using System;
using System.Linq;
using System.Reflection;
//
using Autofac;
using Autofac.Integration.Mvc;
//
using Ray.EssayNotes.AutoFac.Repository.IRepository;
using Ray.EssayNotes.AutoFac.Repository.Repository;


namespace Ray.EssayNotes.AutoFac.Infrastructure.Ioc
{
    /// <summary>
    /// .net framework MVC程式容器
    /// </summary>
    public static class MvcContainer
    {
        public static IContainer Instance;

        /// <summary>
        /// 初始化容器
        /// </summary>
        /// <param name="func"></param>
        /// <returns></returns>
        public static void Init(Func<ContainerBuilder, ContainerBuilder> func = null)
        {
            //新建容器構建器,用於註冊元件和服務
            var builder = new ContainerBuilder();
            //註冊元件
            MyBuild(builder); 
            func?.Invoke(builder);
            //利用構建器建立容器
            Instance = builder.Build();

            //將AutoFac設定為系統DI解析器
            System.Web.Mvc.DependencyResolver.SetResolver(new AutofacDependencyResolver(Instance));
        }

        public static void MyBuild(ContainerBuilder builder)
        {
            Assembly[] assemblies = Helpers.ReflectionHelper.GetAllAssembliesWeb();

            //註冊倉儲 && Service
            builder.RegisterAssemblyTypes(assemblies)//程式集內所有具象類(concrete classes)
                .Where(cc => cc.Name.EndsWith("Repository") |//篩選
                             cc.Name.EndsWith("Service"))
                .PublicOnly()//只要public訪問許可權的
                .Where(cc => cc.IsClass)//只要class型(主要為了排除值和interface型別)
                .AsImplementedInterfaces();//自動以其實現的所有介面型別暴露(包括IDisposable介面)

            //註冊泛型倉儲
            builder.RegisterGeneric(typeof(BaseRepository<>)).As(typeof(IBaseRepository<>));

            //註冊Controller
            //方法1:自己根據反射註冊
            //builder.RegisterAssemblyTypes(assemblies)
            //    .Where(cc => cc.Name.EndsWith("Controller"))
            //    .AsSelf();
            //方法2:用AutoFac提供的專門用於註冊MvcController的擴充套件方法
            Assembly mvcAssembly = assemblies.FirstOrDefault(x => x.FullName.Contains(".NetFrameworkMvc"));
            builder.RegisterControllers(mvcAssembly);
        }
    }
}

專案主程式:

  • Global.asax啟動項

啟動時初始化容器:

using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;
//
using Ray.EssayNotes.AutoFac.Infrastructure.Ioc;


namespace Ray.EssayNotes.AutoFac.NetFrameworkMvc
{
    public class MvcApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            //初始化容器
            MvcContainer.Init();
        }
    }
}
  • 學生控制器:

直接利用構造注入就可以了:

using System.Web.Mvc;
//
using Ray.EssayNotes.AutoFac.Service.IService;


namespace Ray.EssayNotes.AutoFac.NetFrameworkMvc.Controllers
{
    /// <summary>
    /// 學生Api
    /// </summary>
    public class StudentController : Controller
    {
        private readonly IStudentService _studentService;

        /// <summary>
        /// 構造注入
        /// </summary>
        /// <param name="studentService"></param>
        public StudentController(IStudentService studentService)
        {
            _studentService = studentService;
        }

        /// <summary>
        /// 獲取學生姓名
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public string GetStuNameById(long id)
        {
            return _studentService.GetStuName(id);
        }
    }
}

執行呼叫Api

WebApi專案

Api容器

除了AutoFac主包之外,還需要Nuget匯入AutoFac.Api2包:

容器程式碼:

using System;
using System.Linq;
using System.Reflection;
//
using Autofac;
using Autofac.Integration.WebApi;
//
using Ray.EssayNotes.AutoFac.Repository.Repository;
using Ray.EssayNotes.AutoFac.Repository.IRepository;


namespace Ray.EssayNotes.AutoFac.Infrastructure.Ioc
{
    /// <summary>
    /// .NET Framework WebApi容器
    /// </summary>
    public static class ApiContainer
    {
        public static IContainer Instance;

        /// <summary>
        /// 初始化容器
        /// </summary>
        /// <param name="config"></param>
        /// <param name="func"></param>
        public static void Init(System.Web.Http.HttpConfiguration config,Func<ContainerBuilder, ContainerBuilder> func = null)
        {
            //新建容器構建器,用於註冊元件和服務
            var builder = new ContainerBuilder();
            //註冊元件
            MyBuild(builder);
            func?.Invoke(builder);
            //利用構建器建立容器
            Instance = builder.Build();

            //將AutoFac解析器設定為系統解析器
            config.DependencyResolver = new AutofacWebApiDependencyResolver(Instance);
        }

        public static void MyBuild(ContainerBuilder builder)
        {
            var assemblies = Helpers.ReflectionHelper.GetAllAssembliesWeb();

            //註冊倉儲 && Service
            builder.RegisterAssemblyTypes(assemblies)//程式集內所有具象類(concrete classes)
                .Where(cc => cc.Name.EndsWith("Repository") |//篩選
                             cc.Name.EndsWith("Service"))
                .PublicOnly()//只要public訪問許可權的
                .Where(cc => cc.IsClass)//只要class型(主要為了排除值和interface型別)
                .AsImplementedInterfaces();//自動以其實現的所有介面型別暴露(包括IDisposable介面)

            //註冊泛型倉儲
            builder.RegisterGeneric(typeof(BaseRepository<>)).As(typeof(IBaseRepository<>));

            //註冊ApiController
            //方法1:自己根據反射註冊
            //Assembly[] controllerAssemblies = assemblies.Where(x => x.FullName.Contains(".NetFrameworkApi")).ToArray();
            //builder.RegisterAssemblyTypes(controllerAssemblies)
            //    .Where(cc => cc.Name.EndsWith("Controller"))
            //    .AsSelf();
            //方法2:用AutoFac提供的專門用於註冊ApiController的擴充套件方法
            Assembly mvcAssembly = assemblies.FirstOrDefault(x => x.FullName.Contains(".NetFrameworkApi"));
            builder.RegisterApiControllers(mvcAssembly);
        }
    }
}

WebApi主程式

  • Global.asax啟動項

在專案啟動時初始化容器:

using System.Web.Http;
using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;
//
using Ray.EssayNotes.AutoFac.Infrastructure.Ioc;


namespace Ray.EssayNotes.AutoFac.NetFrameworkApi
{
    public class WebApiApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            //獲取HttpConfiguration
            HttpConfiguration config = GlobalConfiguration.Configuration;
            //傳入初始化容器
            ApiContainer.Init(config);
        }
    }
}
  • 學生控制器:

直接利用建構函式注入即可:

using System.Web.Http;
//
using Ray.EssayNotes.AutoFac.Service.IService;


namespace Ray.EssayNotes.AutoFac.NetFrameworkApi.Controllers
{
    /// <summary>
    /// 學生Api
    /// </summary>
    public class StudentController : ApiController
    {
        private readonly IStudentService _studentService;

        /// <summary>
        /// 構造注入
        /// </summary>
        /// <param name="studentService"></param>
        public StudentController(IStudentService studentService)
        {
            _studentService = studentService;
        }

        /// <summary>
        /// 獲取學生姓名
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("Student/GetStuNameById")]
        public string GetStuNameById(long id)
        {
            return _studentService.GetStuName(123);
        }
    }
}

執行介面

第三部分:.NET Core的DI

自帶的DI

與.NET Framework不同,.NET Core把DI提到了非常重要的位置,其框架本身就集成了一套DI容器。
針對其自帶DI,主要理解兩個物件,IServiceCollection和 IServiceProvider。

  • IServiceCollection

用於向容器註冊服務,可以和AutoFac的ContainerBuilder(容器構建器)類比。

  • IServiceProvider

負責從容器中向外部提供例項,可以和AutoFac的解析的概念類比。

註冊的地方就在主程式下的startup類中。

但是其本身的註冊語法並沒有AutoFac那麼豐富,泛型註冊、批量註冊這些全都沒有,只有下面這種最基礎的一個一個註冊的形式:

using System.Linq;
using System.Reflection;
//
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
//
using Ray.EssayNotes.AutoFac.Infrastructure.CoreIoc.Extensions;
using Ray.EssayNotes.AutoFac.Infrastructure.CoreIoc.Helpers;


namespace Ray.EssayNotes.AutoFac.CoreApi
{
    public class Startup
    {
        public IConfiguration Configuration { get; }

        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
            //註冊
            //自定義註冊
            //註冊倉儲
            services.AddScoped<ITeacherRepository, TeacherRepository>();
            services.AddScoped<IStudentRepository, StudentRepository>();
            services.AddScoped<IBaseRepository<StudentEntity>, BaseRepository<StudentEntity>>();
            services.AddScoped<IBaseRepository<TeacherEntity>, BaseRepository<TeacherEntity>>();
            services.AddScoped<IBaseRepository<BookEntity>, BaseRepository<BookEntity>>();
            //註冊Service
            services.AddScoped<IStudentService, StudentService>();
            services.AddScoped<ITeacherService, TeacherService>();
            services.AddScoped<IBookService, BookService>();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
                app.UseHsts();
            }

            app.UseHttpsRedirection();
            app.UseMvc();
        }
    }
}

所以,大家通常都會自己去擴充套件這些註冊方法,以實現一些和AutoFac一樣的便捷的註冊操作,下面我根據反射寫了一個小擴充套件,寫的比較簡單潦草,可以參考下:

擴充套件

擴充套件程式碼:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
//
using Microsoft.Extensions.DependencyInjection;
//
using Ray.EssayNotes.AutoFac.Model;
using Ray.EssayNotes.AutoFac.Repository.IRepository;
using Ray.EssayNotes.AutoFac.Repository.Repository;
using Ray.EssayNotes.AutoFac.Service.IService;
using Ray.EssayNotes.AutoFac.Service.Service;


namespace Ray.EssayNotes.AutoFac.Infrastructure.CoreIoc.Extensions
{
    /// <summary>
    /// asp.net core註冊擴充套件
    /// </summary>
    public static class RegisterExtension
    {
        /// <summary>
        /// 反射批量註冊
        /// </summary>
        /// <param name="services"></param>
        /// <param name="assembly"></param>
        /// <param name="serviceLifetime"></param>
        /// <returns></returns>
        public static IServiceCollection AddAssemblyServices(this IServiceCollection services, Assembly assembly, ServiceLifetime serviceLifetime = ServiceLifetime.Scoped)
        {
            var typeList = new List<Type>();//所有符合註冊條件的類集合

            //篩選當前程式集下符合條件的類
            List<Type> types = assembly.GetTypes().
                Where(t => t.IsClass && !t.IsGenericType)//排除了泛型類
                .ToList();

            typeList.AddRange(types);
            if (!typeList.Any()) return services;

            var typeDic = new Dictionary<Type, Type[]>(); //待註冊集合<class,interface>
            foreach (var type in typeList)
            {
                var interfaces = type.GetInterfaces();   //獲取介面
                typeDic.Add(type, interfaces);
            }

            //迴圈實現類
            foreach (var instanceType in typeDic.Keys)
            {
                Type[] interfaceTypeList = typeDic[instanceType];
                if (interfaceTypeList == null)//如果該類沒有實現介面,則以其本身型別註冊
                {
                    services.AddServiceWithLifeScoped(null, instanceType, serviceLifetime);
                }
                else//如果該類有實現介面,則迴圈其實現的介面,一一配對註冊
                {
                    foreach (var interfaceType in interfaceTypeList)
                    {
                        services.AddServiceWithLifeScoped(interfaceType, instanceType, serviceLifetime);
                    }
                }
            }
            return services;
        }

        /// <summary>
        /// 暴露型別可空註冊
        /// (如果暴露型別為null,則自動以其本身型別註冊)
        /// </summary>
        /// <param name="services"></param>
        /// <param name="interfaceType"></param>
        /// <param name="instanceType"></param>
        /// <param name="serviceLifetime"></param>
        private static void AddServiceWithLifeScoped(this IServiceCollection services, Type interfaceType, Type instanceType, ServiceLifetime serviceLifetime)
        {
            switch (serviceLifetime)
            {
                case ServiceLifetime.Scoped:
                    if (interfaceType == null) services.AddScoped(instanceType);
                    else services.AddScoped(interfaceType, instanceType);
                    break;
                case ServiceLifetime.Singleton:
                    if (interfaceType == null) services.AddSingleton(instanceType);
                    else services.AddSingleton(interfaceType, instanceType);
                    break;
                case ServiceLifetime.Transient:
                    if (interfaceType == null) services.AddTransient(instanceType);
                    else services.AddTransient(interfaceType, instanceType);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(serviceLifetime), serviceLifetime, null);
            }
        }
    }
}

利用這個擴充套件,我們在startup裡就可以用類似AutoFac的語法來註冊了。

主程式

註冊程式碼:

using System.Linq;
using System.Reflection;
//
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
//
using Ray.EssayNotes.AutoFac.Infrastructure.CoreIoc.Extensions;
using Ray.EssayNotes.AutoFac.Infrastructure.CoreIoc.Helpers;


namespace Ray.EssayNotes.AutoFac.CoreApi
{
    public class Startup
    {
        public IConfiguration Configuration { get; }

        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
            //註冊
            
            //自定義批量註冊
            Assembly[] assemblies = ReflectionHelper.GetAllAssembliesCoreWeb();
            //註冊repository
            Assembly repositoryAssemblies = assemblies.FirstOrDefault(x => x.FullName.Contains(".Repository"));
            services.AddAssemblyServices(repositoryAssemblies);
            //註冊service  
            Assembly serviceAssemblies = assemblies.FirstOrDefault(x => x.FullName.Contains(".Service"));
            services.AddAssemblyServices(serviceAssemblies);
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
                app.UseHsts();
            }

            app.UseHttpsRedirection();
            app.UseMvc();
        }
    }
}

其實AutoFac針對.NET Core已經幫我們集成了一套註冊的擴充套件,我們可以通過兩種方式把AutoFac引入.NET Core:一種是將AutoFac容器作為輔助容器,與.NET Core的DI共存,我們可以同時向兩個容器裡註冊元件;一種是讓AutoFac容器接管.NET Core的DI,註冊時只選擇往Autofac容器中註冊。
下面就分別實現下這兩種引入AutoFac的方式。

AutoFac作為輔助註冊

Core容器

先按照之前寫AutoFac容器的方法,新建一個針對Core的AutoFac容器:

using System;
//
using Microsoft.Extensions.DependencyInjection;
//
using Autofac;
using Autofac.Extensions.DependencyInjection;
//
using Ray.EssayNotes.AutoFac.Repository.IRepository;
using Ray.EssayNotes.AutoFac.Repository.Repository;


namespace Ray.EssayNotes.AutoFac.Infrastructure.CoreIoc
{
    /// <summary>
    /// Core的AutoFac容器
    /// </summary>
    public static class CoreContainer
    {
        /// <summary>
        /// 容器例項
        /// </summary>
        public static IContainer Instance;

        /// <summary>
        /// 初始化容器
        /// </summary>
        /// <param name="services"></param>
        /// <param name="func"></param>
        /// <returns></returns>
        public static IServiceProvider Init(IServiceCollection services, Func<ContainerBuilder, ContainerBuilder> func = null)
        {
            //新建容器構建器,用於註冊元件和服務
            var builder = new ContainerBuilder();
            //將Core自帶DI容器內的服務遷移到AutoFac容器
            builder.Populate(services);
            //自定義註冊元件
            MyBuild(builder);
            func?.Invoke(builder);
            //利用構建器建立容器
            Instance = builder.Build();

            return new AutofacServiceProvider(Instance);
        }

        /// <summary>
        /// 自定義註冊
        /// </summary>
        /// <param name="builder"></param>
        public static void MyBuild(this ContainerBuilder builder)
        {
            var assemblies = Helpers.ReflectionHelper.GetAllAssembliesCoreWeb();

            //註冊倉儲 && Service
            builder.RegisterAssemblyTypes(assemblies)
                .Where(cc => cc.Name.EndsWith("Repository") |//篩選
                             cc.Name.EndsWith("Service"))
                .PublicOnly()//只要public訪問許可權的
                .Where(cc => cc.IsClass)//只要class型(主要為了排除值和interface型別)
                .AsImplementedInterfaces();//自動以其實現的所有介面型別暴露(包括IDisposable介面)

            //註冊泛型倉儲
            builder.RegisterGeneric(typeof(BaseRepository<>)).As(typeof(IBaseRepository<>));

            /*
            //註冊Controller
            Assembly[] controllerAssemblies = assemblies.Where(x => x.FullName.Contains(".CoreApi")).ToArray();
            builder.RegisterAssemblyTypes(controllerAssemblies)
                .Where(cc => cc.Name.EndsWith("Controller"))
                .AsSelf();
                */
        }
    }
}

主程式

在主程式中新建一個StartupWithAutoFac類,用於註冊。
StartupWithAutoFac程式碼:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
//
using Autofac;
//
using Ray.EssayNotes.AutoFac.Infrastructure.CoreIoc;


namespace Ray.EssayNotes.AutoFac.CoreApi
{
    public class StartupWithAutoFac
    {
        public IConfiguration Configuration { get; }

        public StartupWithAutoFac(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
        }

        /// <summary>
        /// 利用該方法可以使用AutoFac輔助註冊,該方法在ConfigureServices()之後執行,所以當發生覆蓋註冊時,以後者為準。
        /// 不要再利用構建器去建立AutoFac容器了,系統已經接管了。
        /// </summary>
        /// <param name="builder"></param>
        public void ConfigureContainer(ContainerBuilder builder)
        {
            builder.MyBuild();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
                app.UseHsts();
            }

            app.UseHttpsRedirection();
            app.UseMvc();
        }
    }
}

這裡其他地方與原startup都相同,只是多了一個ConfigureContainer()方法,在該方法內可以按照AutoFac的語法進行自由註冊。

然後修改program類,將AutoFac hook進管道,並將StartupWithAutoFac類指定為註冊入口:

using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;


namespace Ray.EssayNotes.AutoFac.CoreApi
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                //第一種:使用自帶DI
                //.UseStartup<Startup>();

                //第二種:新增AutoFac作為輔助容器
                .HookAutoFacIntoPipeline()
                .UseStartup<StartupWithAutoFac>();

                //第三種:新增AutoFac接管依賴注入
                //.UseStartup<StartupOnlyAutoFac>();
    }
}

AutoFac接管註冊

容器

還是上面的CoreContainer容器。

主程式

主程式新建一個StartupOnlyAutoFac類,
程式碼如下:

using System;
//
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
//
using Ray.EssayNotes.AutoFac.Infrastructure.CoreIoc;


namespace Ray.EssayNotes.AutoFac.CoreApi
{
    public class StartupOnlyAutoFac
    {
        public IConfiguration Configuration { get; }

        public StartupOnlyAutoFac(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        // This method gets called by the runtime. Use this method to add services to the container.
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

            return CoreContainer.Init(services);
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
                app.UseHsts();
            }

            app.UseHttpsRedirection();
            app.UseMvc();
        }
    }
}

這裡直接改了ConfigureServices()方法的返回型別,然後在該方法內直接利用AutoFac註冊。

最後當然也要更改下program類,指定StartupOnlyAutoFac類為註冊入口。
程式碼:

using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;


namespace Ray.EssayNotes.AutoFac.CoreApi
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                //第一種:使用自帶DI
                //.UseStartup<Startup>();

                //第二種:新增AutoFac作為輔助容器
                //.HookAutoFacIntoPipeline()
                //.UseStartup<StartupWithAutoFac>();

                //第三種:新增AutoFac接管依賴注入
                .UseStartup<StartupOnlyAutoFac>();
    }
}

執行呼叫介面: