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

前言

从.Net Core 开始，.Net 平台内置了一个轻量,易用的 IOC 的框架，供我们在应用程序中使用，社区内还有很多强大的第三方的依赖注入框架如：

内置的依赖注入容器基本可以满足大多数应用的需求，除非你需要的特定功能不受它支持否则不建议使用第三方的容器。

我们今天介绍的主角
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
的出现就是为了避免我们在项目中不停地造轮子,达到开箱即用的目的。

本文
完整示例源代码

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

前言

Scanning

第一步获取 types

程序集选择

第二步从 Types 中选择 ImplementationType

第三步确定注册策略

第四步配置注册的场景选择合适的
`ServiceType`

第五步配置生命周期

总结

最后

添加新评论

最新文章

最近回复

分类

归档

其它

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

前言

Scanning

第一步 获取 types

程序集选择

第二步 从 Types 中选择 ImplementationType

第三步确定注册策略

第四步 配置注册的场景选择合适的 ServiceType

第五步 配置生命周期

总结

最后

添加新评论

最新文章

最近回复

分类

归档

其它

第一步获取 types

第二步从 Types 中选择 ImplementationType

第四步配置注册的场景选择合适的
`ServiceType`

第五步配置生命周期