.Net依賴注入神器Scrutor(上)

董瑞鹏發表於2024-03-19
依賴注入

前言

從.Net Core 開始，.Net 平臺內建了一個輕量,易用的 IOC 的框架，供我們在應用程式中使用，社群內還有很多強大的第三方的依賴注入框架如：

  • Autofac
  • DryIOC
  • Grace
  • LightInject
  • Lamar
  • Stashbox
  • Simple Injector

內建的依賴注入容器基本可以滿足大多數應用的需求，除非你需要的特定功能不受它支援否則不建議使用第三方的容器。

我們今天介紹的主角Scrutor是內建依賴注入的一個強大的擴充套件，Scrutor有兩個核心的功能:一是程式集的批次注入 Scanning，二是 Decoration 裝飾器模式，今天的主題是Scanning。

開始之前在專案中安裝 nuget 包:

Install-Package Scrutor

學習Scrutor前我們先熟悉一個.Net依賴注入的萬能用法。

builder.Services.Add(
    new ServiceDescriptor(/*"ServiceType"*/typeof(ISampleService), /*"implementationType"*/typeof(SampleService), ServiceLifetime.Transient)
    );

第一個引數ServiceType通常用介面表示，第二個implementationType介面的實現，最後生命週期，熟悉了這個後面的邏輯理解起來就容易些。

Scrutor官方倉庫和本文完整的原始碼在文末

Scanning

Scrutor提供了一個IServiceCollection的擴充套件方法作為批次注入的入口,該方法提供了Action<ITypeSourceSelector>委託引數。

builder.Services.Scan(typeSourceSelector => { });

我們所有的配置都是在這個委託內完成的，Setup by Setup 剖析一下這個使用過程。

第一步 獲取 types

typeSourceSelector 支援程式集反射獲取型別和提供型別引數

程式集選擇

ITypeSourceSelector有多種獲取程式集的方法來簡化我們選擇程式集

 typeSourceSelector.FromAssemblyOf<Program>();//根據泛型反射獲取所在的程式集

typeSourceSelector.FromCallingAssembly();//獲取開始發起呼叫方法的程式集

typeSourceSelector.FromEntryAssembly();//獲取應用程式入口點所在的程式集

typeSourceSelector.FromApplicationDependencies();//獲取應用程式及其依賴項的程式集

typeSourceSelector.FromDependencyContext(DependencyContext.Default);//根據依賴關係上下文（DependencyContext）中的執行時庫（Runtime Library）列表。它返回一個包含了所有執行時庫資訊的集合。

typeSourceSelector.FromAssembliesOf(typeof(Program));//根據型別獲取程式集的集合

typeSourceSelector.FromAssemblies(Assembly.Load("dotNetParadise-Scrutor.dll"));//提供程式集支援Params或者IEnumerable

第二步 從 Types 中選擇 ImplementationType

簡而言之就是從程式中獲取的所有的 types 進行過濾，比如獲取的 ImplementationType 必須是非抽象的，是類,是否只需要 Public等，還可以用 ImplementationTypeFilter 提供的擴充套件方法等

builder.Services.Scan(typeSourceSelector =>
{
    typeSourceSelector.FromEntryAssembly().AddClasses();
});

AddClasses()方法預設獲取所有公開非抽象的類

還可以透過 AddClasses 的委託引數來進行更多條件的過濾
比如定義一個 Attribute,忽略IgnoreInjectAttribute

namespace dotNetParadise_Scrutor;

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class IgnoreInjectAttribute : Attribute
{
}

builder.Services.Scan(typeSourceSelector =>
{
    typeSourceSelector.FromEntryAssembly().AddClasses(iImplementationTypeFilter =>
    {
        iImplementationTypeFilter.WithoutAttribute<IgnoreInjectAttribute>();
    });
});

利用 iImplementationTypeFilter 的擴充套件方法很簡單就可以實現

在比如 我只要想實現IApplicationService介面的類才可以被注入

namespace dotNetParadise_Scrutor;

/// <summary>
/// 依賴注入標記介面
/// </summary>
public interface IApplicationService
{
}

builder.Services.Scan(typeSourceSelector =>
{
    typeSourceSelector.FromEntryAssembly().AddClasses(iImplementationTypeFilter =>
    {
        iImplementationTypeFilter.WithoutAttribute<IgnoreInjectAttribute>().AssignableTo<IApplicationService>();
    });
});

類似功能還有很多，如可以根據名稱空間也可以根據Type的屬性用lambda表示式對ImplementationType進行過濾

上面的一波操作實際上就是為了構造一個IServiceTypeSelector物件，選出來的ImplementationType物件儲存了到了ServiceTypeSelector的Types屬性中供下一步選擇。
除了提供程式集的方式外還可以直接提供型別的方式比如

建立介面和實現

public interface IForTypeService
{
}
public class ForTypeService : IForTypeService
{
}

builder.Services.Scan(typeSourceSelector =>
{
    typeSourceSelector.FromTypes(typeof(ForTypeService));
});

這種方式提供型別內部會呼叫AddClass()方法把符合條件的引數儲存到ServiceTypeSelector

第三步確定註冊策略

在AddClass之後可以呼叫UsingRegistrationStrategy()配置註冊策略是 Append，Skip，Throw，Replace
下面是各個模式的詳細解釋

  • RegistrationStrategy.Append :類似於builder.Services.Add
  • RegistrationStrategy.Skip:類似於builder.Services.TryAdd
  • RegistrationStrategy.Throw:ServiceDescriptor 重複則跑異常
  • RegistrationStrategy.Replace: 替換原有服務

這樣可以靈活地控制註冊流程

    builder.Services.Scan(typeSourceSelector =>
    {
        typeSourceSelector.FromEntryAssembly().AddClasses().UsingRegistrationStrategy(RegistrationStrategy.Skip);
    });

不指定則為預設的 Append 即 builder.Services.Add

第四步 配置註冊的場景選擇合適的ServiceType

ServiceTypeSelector提供了多種方法讓我們從ImplementationType中匹配ServiceType

  • AsSelf()
  • As<T>()
  • As(params Type[] types)
  • As(IEnumerable<Type> types)
  • AsImplementedInterfaces()
  • AsImplementedInterfaces(Func<Type, bool> predicate)
  • AsSelfWithInterfaces()
  • AsSelfWithInterfaces(Func<Type, bool> predicate)
  • AsMatchingInterface()
  • AsMatchingInterface(Action<Type, IImplementationTypeFilter>? action)
  • As(Func<Type, IEnumerable<Type>> selector)
  • UsingAttributes()

AsSelf 註冊自身

public class AsSelfService
{
}

{
    builder.Services.Scan(typeSourceSelector =>
    {
        typeSourceSelector.FromEntryAssembly().AddClasses(iImplementationTypeFilter =>
        {
            iImplementationTypeFilter.InNamespaces("dotNetParadise_Scrutor.Application.AsSelf").WithoutAttribute<IgnoreInjectAttribute>();
        }).AsSelf();
    });

    Debug.Assert(builder.Services.Any(_ => _.ServiceType == typeof(AsSelfService)));
}

等效於builder.Services.AddTransient<AsSelfService>();

As 批次為 ImplementationType 指定 ServiceType

public interface IAsService
{
}
public class AsOneService : IAsService
{
}
public class AsTwoService : IAsService
{
}

{
    builder.Services.Scan(typeSourceSelector =>
{
    typeSourceSelector.FromEntryAssembly().AddClasses(iImplementationTypeFilter =>
    {
        iImplementationTypeFilter.InNamespaces("dotNetParadise_Scrutor.Application.As").WithoutAttribute<IgnoreInjectAttribute>();
    }).As<IAsService>();
});
    Debug.Assert(builder.Services.Any(_ => _.ServiceType == typeof(IAsService)));
    foreach (var asService in builder.Services.Where(_ => _.ServiceType == typeof(IAsService)))
    {
        Debug.WriteLine(asService.ImplementationType!.Name);
    }
}

As(params Type[] types)和 As(IEnumerable types) 批次為ImplementationType指定多個 ServiceType，服務必須同時實現這裡面的所有的介面

上面的例項再改進一下

public interface IAsOtherService
{
}
public interface IAsSomeService
{
}

public class AsOneMoreTypesService : IAsOtherService, IAsSomeService
{
}
public class AsTwoMoreTypesService : IAsSomeService, IAsOtherService
{
}


{
    builder.Services.Scan(typeSourceSelector =>
    {
        typeSourceSelector.FromEntryAssembly().AddClasses(iImplementationTypeFilter =>
        {
            iImplementationTypeFilter.InNamespaces("dotNetParadise_Scrutor.Application.AsMoreTypes").WithoutAttribute<IgnoreInjectAttribute>();
        }).As(typeof(IAsSomeService), typeof(IAsOtherService));
    });
    List<Type> serviceTypes = [typeof(IAsSomeService), typeof(IAsOtherService)];
    Debug.Assert(serviceTypes.All(serviceType => builder.Services.Any(service => service.ServiceType == serviceType)));
    foreach (var asService in builder.Services.Where(_ => _.ServiceType == typeof(IAsSomeService) || _.ServiceType == typeof(IAsOtherService)))
    {
        Debug.WriteLine(asService.ImplementationType!.Name);
    }
}

AsImplementedInterfaces 註冊當前 ImplementationType 和實現的介面

public interface IAsImplementedInterfacesService
{
}
public class AsImplementedInterfacesService : IAsImplementedInterfacesService
{
}

//AsImplementedInterfaces 註冊當前ImplementationType和它實現的介面
{
    builder.Services.Scan(typeSourceSelector =>
    {
        typeSourceSelector.FromEntryAssembly().AddClasses(iImplementationTypeFilter =>
        {
            iImplementationTypeFilter.InNamespaces("dotNetParadise_Scrutor.Application.AsImplementedInterfaces").WithoutAttribute<IgnoreInjectAttribute>();
        }).AsImplementedInterfaces();
    });

    Debug.Assert(builder.Services.Any(service => service.ServiceType == typeof(IAsImplementedInterfacesService)));
    foreach (var asService in builder.Services.Where(_ => _.ServiceType == typeof(IAsImplementedInterfacesService)))
    {
        Debug.WriteLine(asService.ImplementationType!.Name);
    }
}

AsSelfWithInterfaces 同時註冊為自身型別和所有實現的介面

public interface IAsSelfWithInterfacesService
{
}
public class AsSelfWithInterfacesService : IAsSelfWithInterfacesService
{
}


{
    builder.Services.Scan(typeSourceSelector =>
    {
        typeSourceSelector.FromEntryAssembly().AddClasses(iImplementationTypeFilter =>
        {
            iImplementationTypeFilter.InNamespaces("dotNetParadise_Scrutor.Application.AsSelfWithInterfaces").WithoutAttribute<IgnoreInjectAttribute>();
        }).AsSelfWithInterfaces();
    });
    //Self
    Debug.Assert(builder.Services.Any(service => service.ServiceType == typeof(AsSelfWithInterfacesService)));
    //Interfaces
    Debug.Assert(builder.Services.Any(service => service.ServiceType == typeof(IAsSelfWithInterfacesService)));
    foreach (var service in builder.Services.Where(_ => _.ServiceType == typeof(AsSelfWithInterfacesService) || _.ServiceType == typeof(IAsSelfWithInterfacesService)))
    {
        Debug.WriteLine(service.ServiceType!.Name);
    }
}

AsMatchingInterface 將服務註冊為與其命名相匹配的介面，可以理解為一定約定假如服務名稱為 ClassName,會找 IClassName 的介面作為 ServiceType 註冊

public interface IAsMatchingInterfaceService
{
}
public class AsMatchingInterfaceService : IAsMatchingInterfaceService
{
}

//AsMatchingInterface 將服務註冊為與其命名相匹配的介面，可以理解為一定約定假如服務名稱為 ClassName,會找 IClassName 的介面作為 ServiceType 註冊
{
    builder.Services.Scan(typeSourceSelector =>
    {
        typeSourceSelector.FromEntryAssembly().AddClasses(iImplementationTypeFilter =>
        {
            iImplementationTypeFilter.InNamespaces("dotNetParadise_Scrutor.Application.AsMatchingInterface").WithoutAttribute<IgnoreInjectAttribute>();
        }).AsMatchingInterface();
    });
    Debug.Assert(builder.Services.Any(service => service.ServiceType == typeof(IAsMatchingInterfaceService)));
    foreach (var service in builder.Services.Where(_ => _.ServiceType == typeof(IAsMatchingInterfaceService)))
    {
        Debug.WriteLine(service.ServiceType!.Name);
    }
}

UsingAttributes 特性注入，這個還是很實用的在Scrutor提供了ServiceDescriptorAttribute來幫助我們方便的對Class進行標記方便注入

public interface IUsingAttributesService
{
}

[ServiceDescriptor<IUsingAttributesService>()]
public class UsingAttributesService : IUsingAttributesService
{
}

    builder.Services.Scan(typeSourceSelector =>
    {
        typeSourceSelector.FromEntryAssembly().AddClasses(iImplementationTypeFilter =>
        {
            iImplementationTypeFilter.InNamespaces("dotNetParadise_Scrutor.Application.UsingAttributes").WithoutAttribute<IgnoreInjectAttribute>();
        }).UsingAttributes();
    });
    Debug.Assert(builder.Services.Any(service => service.ServiceType == typeof(IUsingAttributesService)));
    foreach (var service in builder.Services.Where(_ => _.ServiceType == typeof(IUsingAttributesService)))
    {
        Debug.WriteLine(service.ServiceType!.Name);
    }

第五步 配置生命週期

透過鏈式呼叫WithLifetime函式來確定我們的生命週期，預設是 Transient

public interface IFullService
{
}
public class FullService : IFullService
{
}

{

    builder.Services.Scan(typeSourceSelector =>
    {
        typeSourceSelector.FromEntryAssembly().AddClasses(iImplementationTypeFilter =>
        {
            iImplementationTypeFilter.InNamespaces("dotNetParadise_Scrutor.Application.Full");
        }).UsingRegistrationStrategy(RegistrationStrategy.Skip).AsImplementedInterfaces().WithLifetime(ServiceLifetime.Scoped);
    });

    Debug.Assert(builder.Services.Any(service => service.ServiceType == typeof(IFullService)));
    foreach (var service in builder.Services.Where(_ => _.ServiceType == typeof(IFullService)))
    {
        Debug.WriteLine($"serviceType：{service.ServiceType!.Name},LifeTime:{service.Lifetime}");
    }
}

總結

到這兒基本的功能已經介紹完了，可以看出來擴充套件方法很多，基本可以滿足開發過程批次依賴注入的大部分場景。
使用技巧總結：

  • 根據程式集獲取所有的型別 此時 Scrutor 會返回一個 IImplementationTypeSelector 物件裡面包含了程式集的所有型別集合
  • 呼叫 IImplementationTypeSelector 的 AddClasses 方法獲取 IServiceTypeSelector 物件,AddClass 這裡面可以根據條件選擇 過濾一些不需要的型別
  • 呼叫UsingRegistrationStrategy確定依賴注入的策略 是覆蓋 還是跳過亦或是丟擲異常 預設 Append 追加註入的方式
  • 配置註冊的場景 比如是 AsImplementedInterfaces 還是 AsSelf等
  • 選擇生命週期 預設 Transient

藉助ServiceDescriptorAttribute更簡單，生命週期和ServiceType都是在Attribute指定好的只需要確定選擇程式集，呼叫UsingRegistrationStrategy配置依賴注入的策略然後UsingAttributes()即可

最後

本文從Scrutor的使用流程剖析了依賴注入批次註冊的流程，更詳細的教程可以參考Github 官方倉庫。在開發過程中看到很多專案還有一個個手動注入的，也有自己寫 Interface或者是Attribute反射注入的，支援的場景都十分有限，Scrutor的出現就是為了避免我們在專案中不停地造輪子,達到開箱即用的目的。

本文完整示例原始碼

相關文章