系列目錄
前言
本來計劃是五篇文章的，每章發個半小時隨便翻翻就能懂，但是第一篇發了之後，我發現.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專案
思路很簡單，三步走：
新建AutoFac容器
初始化容器，向容器註冊所有需要的依賴物件
將AutoFac解析器設定為系統的依賴解析器(Dependency Resolver)
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>
/// 初始化MVC容器
/// </summary>
/// <param name="func"></param>
/// <returns></returns>
public static System.Web.Mvc.IDependencyResolver Init(Func<ContainerBuilder, ContainerBuilder> func = null)
{
//新建容器構建器，用於註冊元件和服務
var builder = new ContainerBuilder();
//註冊元件
MyBuild(builder);
func?.Invoke(builder);
//利用構建器建立容器
Instance = builder.Build();
//返回針對MVC的AutoFac解析器
return 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);
}
}
}這裡Init()初始化函式返回型別變成了System.Web.Mvc.IDependencyResolver介面，即MVC的系統依賴解析器。
AutoFac自己封裝了一個AutofacDependencyResolver類（AutoFac依賴解析器類）實現了這個介面，所以直接new一個AutofacDependencyResolver類返回，等下把這個AutoFac依賴解析器類設定為MVC的系統依賴解析器就可以了。
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;
using System.Web.Mvc;
namespace Autofac.Integration.Mvc
{
/// <summary>
/// Autofac implementation of the <see cref="T:System.Web.Mvc.IDependencyResolver" /> interface.
/// </summary>
public class AutofacDependencyResolver : IDependencyResolver
{
//內部實現
//......
}專案主程式：
- Global.asax啟動項
啟動時初始化容器，並把AutoFac生成的解析器設定為系統依賴解析器：
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);
//初始化容器，並返回適用於MVC的AutoFac解析器
System.Web.Mvc.IDependencyResolver autoFacResolver = MvcContainer.Init();
//將AutoFac解析器設定為系統DI解析器
DependencyResolver.SetResolver(autoFacResolver);
}
}
}
其中DependencyResolver.SetResolver()為MVC封裝的一個靜態方法，用於設定MVC的依賴解析器。
其引數只要是實現了System.Web.Mvc.IDependencyResolver介面的物件都可以，AutoFac自己封裝的解析器AutofacDependencyResolver類實現了這個介面，所以可以傳進來，從而實現了讓AutoFac接管MVC的依賴注入。
- 學生控制器：
直接利用構造注入就可以了：
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專案
和MVC一樣，思路很簡單，三步走：
新建AutoFac容器
初始化容器，向容器註冊所有需要的依賴物件
將AutoFac解析器設定為系統的依賴解析器(Dependency Resolver)
Api容器
除了AutoFac主包之外，還需要Nuget匯入AutoFac.WebApi2包：
容器程式碼：
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>
/// 初始化Api容器
/// </summary>
/// <param name="func"></param>
public static System.Web.Http.Dependencies.IDependencyResolver Init(Func<ContainerBuilder, ContainerBuilder> func = null)
{
//新建容器構建器，用於註冊元件和服務
var builder = new ContainerBuilder();
//註冊元件
MyBuild(builder);
func?.Invoke(builder);
//利用構建器建立容器
Instance = builder.Build();
//返回針對WebApi的AutoFac解析器
return 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);
}
}
}
這裡Init()初始化函式返回型別變成了System.Web.Http.Dependencies.IDependencyResolver介面，即WebApi的系統依賴解析器。
AutoFac自己封裝了一個AutofacWebApiDependencyResolver類（AutoFac針對WebApi的依賴解析器類）實現了這個介面，所以直接new一個AutofacWebApiDependencyResolver類返回，等下把這個AutoFac依賴解析器類設定為WebApi的系統依賴解析器就可以了。
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);
//初始化容器，並返回適用於WebApi的AutoFac解析器
System.Web.Http.Dependencies.IDependencyResolver autoFacResolver = ApiContainer.Init();
//獲取HttpConfiguration
HttpConfiguration config = GlobalConfiguration.Configuration;
//將AutoFac解析器設定為系統DI解析器
config.DependencyResolver = autoFacResolver;
}
}
}
這裡跟上面的MVC專案不太一樣，是通過HttpConfiguration物件來設定依賴解析器的，但是原理相同，不贅述了。
- 學生控制器：
直接利用建構函式注入即可：
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>();
}
}
執行呼叫
- StudentController
using Microsoft.AspNetCore.Mvc;
//
using Ray.EssayNotes.AutoFac.Service.IService;
namespace Ray.EssayNotes.AutoFac.CoreApi.Controllers
{
[ApiController]
public class StudentController : ControllerBase
{
private readonly IStudentService _studentService;
public StudentController(IStudentService studentService)
{
_studentService = studentService;
}
[Route("Student/GetStuNameById")]
public string GetStuNameById(long id)
{
return _studentService.GetStuName(id);
}
}
}- 呼叫
