ServiceScan.SourceGenerator

Source generator for services registrations inspired by Scrutor. Code generation allows to have AOT-compatible code, without an additional hit on startup performance due to runtime assembly scanning.

Installation

Add the NuGet Package to your project:

dotnet add package ServiceScan.SourceGenerator

Usage

ServiceScan generates a partial method implementation based on GenerateServiceRegistrations attribute. This attribute can be added to a partial method with IServiceCollection parameter. For example, based on the following partial method:

publicstaticpartialclassServicesExtensions{[GenerateServiceRegistrations(AssignableTo=typeof(IMyService),Lifetime=ServiceLifetime.Scoped)]publicstaticpartialIServiceCollectionAddServices(thisIServiceCollectionservices);}

ServiceScan will generate the following implementation:

publicstaticpartialclassServicesExtensions{publicstaticpartialIServiceCollectionAddServices(thisIServiceCollectionservices){returnservices.AddScoped<IMyService,ServiceImplementation1>().AddScoped<IMyService,ServiceImplementation2>();}}

The only thing left is to invoke this method on your IServiceCollection instance

services.AddServices();

Examples

Register all FluentValidation validators

Unlike using FluentValidation.DependencyInjectionExtensions package, ServiceScan is AOT-compatible, and doesn't affect startup performance:

[GenerateServiceRegistrations(AssignableTo=typeof(IValidator<>),Lifetime=ServiceLifetime.Singleton)]publicstaticpartialIServiceCollectionAddValidators(thisIServiceCollectionservices);

Add MediatR handlers

publicstaticIServiceCollectionAddMediatR(thisIServiceCollectionservices){returnservices.AddTransient<IMediator,Mediator>().AddMediatRHandlers();}[GenerateServiceRegistrations(AssignableTo=typeof(IRequestHandler<>),Lifetime=ServiceLifetime.Transient)][GenerateServiceRegistrations(AssignableTo=typeof(IRequestHandler<,>),Lifetime=ServiceLifetime.Transient)]privatestaticpartialIServiceCollectionAddMediatRHandlers(thisIServiceCollectionservices);

It adds MediatR requests handlers, although you might need to add other types like PipelineBehaviors or NotificationHandlers.

Add all repository types from your project based on name filter as their implemented interfaces:

[GenerateServiceRegistrations(TypeNameFilter="*Repository",AsImplementedInterfaces=true,Lifetime=ServiceLifetime.Scoped)]publicstaticpartialIServiceCollectionAddRepositories(thisIServiceCollectionservices);

Add AspNetCore Minimal API endpoints

You can add custom type handler, if you need to do something non-trivial with that type. For example, you can automatically discover and map Minimal API endpoints:

publicinterfaceIEndpoint{abstractstaticvoidMapEndpoint(IEndpointRouteBuilderendpoints);}publicclassHelloWorldEndpoint:IEndpoint{publicstaticvoidMapEndpoint(IEndpointRouteBuilderendpoints){endpoints.MapGet("/",()=>"Hello World!");}}publicstaticpartialclassServiceCollectionExtensions{[ScanForTypes(AssignableTo=typeof(IEndpoint),Handler=nameof(IEndpoint.MapEndpoint))]publicstaticpartialIEndpointRouteBuilderMapEndpoints(thisIEndpointRouteBuilderendpoints);}

Register Options types

Another example of Handler is to register Options types. We can define custom OptionAttribute, which allows to specify configuration section key. And then read that value in our Handler:

[AttributeUsage(AttributeTargets.Class,AllowMultiple=false)]publicclassOptionAttribute(string?section=null):Attribute{publicstring?Section{get;}=section;}[Option]publicrecordRootSection{}[Option("SectionOption")]publicrecordSectionOption{}publicstaticpartialclassServiceCollectionExtensions{[ScanForTypes(AttributeFilter=typeof(OptionAttribute),Handler=nameof(AddOption))]publicstaticpartialIServiceCollectionAddOptions(thisIServiceCollectionservices,IConfigurationconfiguration);privatestaticvoidAddOption<T>(IServiceCollectionservices,IConfigurationconfiguration)whereT:class{varsectionKey=typeof(T).GetCustomAttribute<OptionAttribute>()?.Section;varsection=sectionKeyisnull?configuration:configuration.GetSection(sectionKey);services.Configure<T>(section);}}

Apply EF Core IEntityTypeConfiguration types

publicstaticpartialclassModelBuilderExtensions{[ScanForTypes(AssignableTo=typeof(IEntityTypeConfiguration<>),Handler=nameof(ApplyConfiguration))]publicstaticpartialModelBuilderApplyEntityConfigurations(thisModelBuildermodelBuilder);privatestaticvoidApplyConfiguration<T,TEntity>(ModelBuildermodelBuilder)whereT:IEntityTypeConfiguration<TEntity>,new()whereTEntity:class{modelBuilder.ApplyConfiguration(newT());}}

Get all matched types as a collection

When Handler is omitted and the method returns Type[] or IEnumerable<Type>, ScanForTypes returns a collection of matched types:

publicstaticpartialclassTypeDiscovery{[ScanForTypes(AssignableTo=typeof(IService))]publicstaticpartialType[]GetAllServiceTypes();}

Map matched types to a custom result type

When the method returns TResponse[] or IEnumerable<TResponse>, specify a Handler that maps each found type to TResponse:

publicstaticpartialclassTypeDiscovery{[ScanForTypes(AssignableTo=typeof(IService),Handler=nameof(Describe))]publicstaticpartialServiceDescriptor[]GetServiceDescriptors();privatestaticServiceDescriptorDescribe<T>()whereT:IService=>ServiceDescriptor.Transient(typeof(IService),typeof(T));}

Use a template expression for each matched type

When Handler is not flexible enough — for example when you need to pass extra arguments, call static methods with multiple parameters, or perform typeof manipulations — use HandlerTemplate. The placeholder T is replaced with the fully-qualified name of each matched type at code-generation time.

Instantiate types with constructor arguments:

publicstaticpartialclassFactory{[ScanForTypes(AssignableTo=typeof(IPlugin),HandlerTemplate="new T(options)")]publicstaticpartialIPlugin[]CreatePlugins(PluginOptionsoptions);}

Call a static factory method that takes multiple parameters:

publicstaticpartialclassPipelineBuilder{[ScanForTypes(AssignableTo=typeof(IPipelineStep),HandlerTemplate="T.Create(context, logger)")]publicstaticpartialIPipelineStep[]BuildSteps(PipelineContextcontext,ILoggerlogger);}

Build descriptor objects using typeof(T) and additional context:

publicstaticpartialclassHandlerRegistry{[ScanForTypes(AssignableTo=typeof(ICommandHandler),HandlerTemplate="new HandlerDescriptor(typeof(T), category)")]publicstaticpartialHandlerDescriptor[]GetDescriptors(stringcategory);}

HandlerTemplate works equally well with void methods, where each expanded expression becomes a statement:

publicstaticpartialclassPluginLoader{[ScanForTypes(AssignableTo=typeof(IPlugin),HandlerTemplate="registry.Add(new T(options))")]publicstaticpartialvoidRegisterPlugins(PluginRegistryregistry,PluginOptionsoptions);}

Parameters

GenerateServiceRegistrations attribute has the following properties:

Property	Description
FromAssemblyOf	Sets the assembly containing the given type as the source of types to register. If not specified, the assembly containing the method with this attribute will be used.
AssemblyNameFilter	Sets this value to filter scanned assemblies by assembly name. It allows applying an attribute to multiple assemblies. For example, this allows scanning all assemblies from your solution. This option is incompatible with FromAssemblyOf. You can use '*' wildcards. You can also use ',' to separate multiple filters. Be careful to include a limited number of assemblies, as it can affect build and editor performance.
AssignableTo	Sets the type that the registered types must be assignable to. Types will be registered with this type as the service type, unless AsImplementedInterfaces or AsSelf is set.
ExcludeAssignableTo	Sets the type that the registered types must not be assignable to.
Lifetime	Sets the lifetime of the registered services. ServiceLifetime.Transient is used if not specified.
AsImplementedInterfaces	If set to true, types will be registered as their implemented interfaces instead of their actual type.
AsSelf	If set to true, types will be registered with their actual type. It can be combined with AsImplementedInterfaces. In this case, implemented interfaces will be "forwarded" to the "self" implementation.
TypeNameFilter	Sets this value to filter the types to register by their full name. You can use '*' wildcards. You can also use ',' to separate multiple filters.
AttributeFilter	Filters types by the specified attribute type being present.
ExcludeByTypeName	Sets this value to exclude types from being registered by their full name. You can use '*' wildcards. You can also use ',' to separate multiple filters.
ExcludeByAttribute	Excludes matching types by the specified attribute type being present.
KeySelector	Sets this property to add types as keyed services. This property should point to one of the following: - The name of a static method in the current type with a string return type. The method should be either generic or have a single parameter of type Type. - A constant field or static property in the implementation type.
CustomHandler	(Obsolete — use ScanForTypes instead.) Sets this property to invoke a custom method for each type found instead of regular registration logic.

ScanForTypes attribute is used to invoke a custom method for each matched type. It has the same filtering properties as GenerateServiceRegistrations, but without the registration-specific ones (Lifetime, AsImplementedInterfaces, AsSelf, KeySelector):

Property	Description
Handler	Sets this property to invoke a custom method for each type found. This property should point to one of the following: - Name of a generic method in the current type. - nameof(OtherType.Method) for a static generic method on another type. - Static method name in found types. Note: Types are automatically filtered by the generic constraints defined on the method's type parameters (e.g., class, struct, new(), interface constraints).
HandlerTemplate	Sets an expression template to evaluate for each type found. Use T as a placeholder for the fully-qualified name of each matched type. For collection-returning methods the template is the element expression; for void methods it becomes a statement (a ; is appended automatically if absent). Incompatible with Handler.
FromAssemblyOf	Sets the assembly containing the given type as the source of types to scan. If not specified, the assembly containing the method with this attribute will be used.
AssemblyNameFilter	Sets this value to filter scanned assemblies by assembly name. This option is incompatible with FromAssemblyOf. You can use '*' wildcards. You can also use ',' to separate multiple filters.
AssignableTo	Sets the type that the scanned types must be assignable to.
ExcludeAssignableTo	Sets the type that the scanned types must not be assignable to.
TypeNameFilter	Sets this value to filter the types by their full name. You can use '*' wildcards. You can also use ',' to separate multiple filters.
AttributeFilter	Filters types by the specified attribute type being present.
ExcludeByTypeName	Sets this value to exclude types by their full name. You can use '*' wildcards. You can also use ',' to separate multiple filters.
ExcludeByAttribute	Excludes matching types by the specified attribute type being present.