Scrutor para C# (.NET): guia completo com exemplos práticos

Scrutor é uma biblioteca de código aberto para a plataforma .NET que estende o mecanismo nativo de injeção de dependência (Dependency Injection, DI) com recursos de varredura automática de assemblies (assembly scanning). Ela permite registrar serviços no contêiner DI com base em convenções de nomenclatura, atributos ou interfaces, simplificando significativamente a configuração do contêiner IoC em projetos de grande porte.

Por que usar esta biblioteca? No contêiner padrão Microsoft.Extensions.DependencyInjection, cada serviço precisa ser registrado manualmente: services.AddScoped<IMyService, MyService>(). Em um projeto com dezenas ou centenas de serviços, isso resulta em código inchado no Startup.cs ou Program.cs, reduz a legibilidade e aumenta o risco de erros. O Scrutor resolve esse problema permitindo registrar todos os serviços de um assembly com uma única linha: services.Scan(scan => scan.FromAssemblyOf<IMyService>()...).

O Scrutor é especialmente útil em arquiteturas que utilizam Domain-Driven Design (DDD), Clean Architecture ou monolitos modulares. Ele encontra automaticamente todas as implementações de interfaces, classes com atributos específicos (como [ServiceDescriptor]) ou classes que seguem padrões de nomenclatura definidos (por exemplo, todas as classes que terminam com "Repository"). Isso torna o código mais limpo e adicionar novos serviços uma tarefa trivial, sem necessidade de alterar a configuração de DI.

Instalação

O Scrutor é instalado através do NuGet Package Manager. Execute um dos seguintes comandos:

# Via .NET CLI
dotnet add package Scrutor

# Via Package Manager Console (Visual Studio)
Install-Package Scrutor

Após a instalação, uma referência à biblioteca Scrutor será adicionada ao projeto. Certifique-se de ter o .NET SDK versão 6.0 ou superior instalado (recomenda-se .NET 8.0+).

Início rápido

Vamos a um exemplo mínimo funcional. Criaremos um aplicativo de console com três arquivos: a interface IGreetingService, sua implementação GreetingService e o ponto de entrada Program.cs.

// IGreetingService.cs
public interface IGreetingService
{
    string Greet(string name);
}

// GreetingService.cs
public class GreetingService : IGreetingService
{
    public string Greet(string name) => $"Olá, {name}!";
}

// Program.cs
using Microsoft.Extensions.DependencyInjection;
using Scrutor;

var services = new ServiceCollection();

// Registro manual (abordagem tradicional)
// services.AddTransient<IGreetingService, GreetingService>();

// Registro via Scrutor (varredura de assembly)
services.Scan(scan => scan
    .FromAssemblyOf<IGreetingService>() // Varre o assembly que contém IGreetingService
    .AddClasses(classes => classes.AssignableTo<IGreetingService>()) // Procura classes que implementam IGreetingService
    .AsImplementedInterfaces() // Registra como implementação da interface
    .WithTransientLifetime()); // Define o tempo de vida como Transient

var serviceProvider = services.BuildServiceProvider();
var greetingService = serviceProvider.GetRequiredService<IGreetingService>();
Console.WriteLine(greetingService.Greet("Mundo"));
// Saída: Olá, Mundo!

Neste exemplo, o Scrutor encontra automaticamente a classe GreetingService no mesmo assembly que a interface IGreetingService e a registra como Transient. Se você adicionar uma nova implementação de IGreetingService, ela será registrada automaticamente sem precisar alterar o código do Program.cs.

Métodos e classes principais

O Scrutor fornece uma API fluente para construir cadeias de chamadas. Vamos explorar 8 métodos/classes principais com suas assinaturas, descrições e exemplos.

1. Scan(IServiceCollection, Action<ITypeSourceSelector>)