How do I use Scrutor to add logging decorators to my services?

Use the Decorate method on IServiceCollection to wrap existing services with logging decorators. For example, after registering a service, call collection.Decorate () to inject logging logic without modifying the original implementation.

Scrutor vs Autofac: which is better for dependency injection?

Scrutor is best if you're committed to Microsoft's DI container and need lightweight scanning and decoration. Autofac offers more advanced features like module systems and property injection, but requires switching containers entirely.

Can Scrutor work with .NET 8 and Blazor applications?

Yes, Scrutor is compatible with .NET 8 and Blazor, as it builds on Microsoft.Extensions.DependencyInjection. Use it in Program.cs to scan assemblies or decorate services, just like in other ASP.NET Core projects.

How to exclude certain namespaces from Scrutor scanning?

Use the AddClasses method with filters like .InNamespaces() to include only specific namespaces, or chain .Where() clauses to exclude types. The README shows examples of filtering by namespace and attributes for precise control.

Is Scrutor thread-safe during service registration?

Scrutor's extension methods on IServiceCollection are designed to be used during application startup, where thread safety isn't typically a concern. However, avoid concurrent modifications to the service collection to prevent issues.

What happens if I decorate a service multiple times with Scrutor?

Decorations are applied in the order they are registered, creating a chain of decorators. For instance, in the example, OtherDecorator wraps Decorator wraps Decorated, allowing layered cross-cutting concerns.

Open-Awesome

Scrutor

MITC#v7.0.0

Assembly scanning and decoration extensions for Microsoft.Extensions.DependencyInjection in .NET applications.

GitHub

4.4k stars280 forks0 contributors

What is Scrutor?

Scrutor is a .NET library that extends Microsoft.Extensions.DependencyInjection with assembly scanning and service decoration capabilities. It solves the problem of manually registering numerous services in dependency injection containers by automatically discovering types from assemblies, and enables clean implementation of the decorator pattern for cross-cutting concerns.

Target Audience

.NET developers using Microsoft's dependency injection container who need to reduce boilerplate service registration code or implement decorator patterns for cross-cutting concerns like logging, caching, or validation.

Value Proposition

Developers choose Scrutor because it provides missing but essential functionality for the standard Microsoft DI container with a clean, intuitive API that follows existing .NET patterns, eliminating the need for manual service registration or complex workarounds for decoration.

Overview

Assembly scanning and decoration extensions for Microsoft.Extensions.DependencyInjection

Use Cases

Best For

Automatically registering all repository or service classes in a large .NET application
Implementing decorator patterns for cross-cutting concerns like logging or caching in ASP.NET Core
Reducing boilerplate dependency injection setup code in microservices architectures
Registering compiler-generated UI types from frameworks like Avalonia
Handling open generic interfaces in dependency injection configurations
Applying consistent service lifetimes across multiple discovered implementations

Not Ideal For

Projects already using third-party DI containers like Autofac or Simple Injector with built-in scanning features
Applications with only a handful of services where manual registration is straightforward and maintainable
Teams requiring compile-time dependency validation or advanced DI features like property injection
Scenarios where performance is critical and assembly scanning overhead is unacceptable for large codebases

Pros & Cons

Pros

Efficient Assembly Scanning

Automatically discovers and registers types from assemblies using configurable filters, drastically reducing boilerplate code for DI setup, as shown in the scanning examples.

Clean Decorator Support

Provides a straightforward API to decorate services for cross-cutting concerns like logging or caching, enabling the decorator pattern without modifying original implementations.

Flexible Type Filtering

Supports filtering by base types, interfaces, namespaces, attributes, and even compiler-generated types for UI frameworks like Avalonia, as detailed in the README.

Open Generic Handling

Capable of scanning and registering open generic interfaces and types with multiple parameters, simplifying DI for generic patterns.

Cons

Compiler-Generated Type Pitfalls

The README warns that compiler-generated types (e.g., from UI frameworks) can implement many interfaces, leading to unintended registrations if filters are not precise, requiring careful configuration.

Limited to Microsoft DI

Scrutor only extends Microsoft.Extensions.DependencyInjection, creating vendor lock-in and making it unsuitable for projects using alternative containers with more features.

Potential Performance Overhead

Assembly scanning can introduce startup performance issues in large applications, as it reflects over all types, which might not be optimal for high-performance or minimal overhead scenarios.

Frequently Asked Questions

Related Projects

Microsoft.Extensions.DependencyInjection

.NET is a cross-platform runtime for cloud, mobile, desktop, and IoT apps.

A convention-based object-object mapper in .NET.

Stars10,187

Forks2,398

Last commit6 days ago

Humanizer

Humanizer meets all your .NET needs for manipulating and displaying strings, enums, dates, times, timespans, numbers and quantities

Stars9,938

Forks1,067