How do you register and resolve open generic types in .NET dependency injection, for example services.AddScoped(typeof(IRepository<>), typeof(Repository<>))? Explain how the container closes the type, how closed registrations override it, lifetimes, decorators and the limits of Microsoft.Extensions.DependencyInjection.

1. Under the hood of MS DI

ServiceCollection stores ServiceDescriptors. For open generics, ServiceType and ImplementationType are generic type definitions. CallSiteFactory handles resolution:

• Exact match lookup for closed descriptors first.
• If none, check serviceType.IsConstructedGenericType and look up descriptors by GetGenericTypeDefinition().
• Create the closed implementation type via MakeGenericType, catching ArgumentException for constraint violations (so incompatible open generic registrations are skipped for IEnumerable<T>).
• Build a call site (constructor call site with dependency call sites), then compile it to a resolver (expression trees / IL emit, or interpretation under AOT).

The resulting call sites are cached per service type.

2. IEnumerable<T> resolution order

For IEnumerable<IHandler<OrderPlaced>>, MS DI returns all matching registrations in registration order, including open generic closures and closed registrations. Ordering matters for pipelines — register in the order you want them executed, or have explicit ordering in your dispatcher.

3. Generic constraints and registration

public sealed class EfRepository<T> : IRepository<T> where T : class, IAggregateRoot { ... }

Requesting IRepository<OrderLine> (not an aggregate root) fails at resolution with an error explaining constraint violation — useful as an architectural guardrail ("repositories only for aggregates").

4. Decorators with Scrutor

Decorate replaces the existing descriptor with one that resolves the inner implementation and wraps it. For open generics, Scrutor creates a new open generic decorator registration that closes both decorator and inner type. Order matters: decorators applied later wrap earlier ones.

5. Keyed services and generics

.NET 8 keyed services (AddKeyedScoped(typeof(IExporter<>), "csv", typeof(CsvExporter<>))) support open generics, resolved with [FromKeyedServices("csv")] IExporter<Order> or GetRequiredKeyedService. Useful for strategy selection by configuration.

6. Source-generated DI

For NativeAOT or faster start-up, some teams use compile-time containers (e.g. Jab, Pure.DI) or source-generated registration code. These require closed types known at compile time, which conflicts with open generic flexibility — another trade-off.

Try it yourself

1. Register IRepository<>/EfRepository<> and a closed override; resolve both a generic and the overridden type.
2. Add a constraint to the implementation and resolve a type that violates it; read the error.
3. Add Scrutor and decorate the open generic with a caching decorator.
4. Enable ValidateScopes and register a generic singleton depending on DbContext; resolve it.

using Microsoft.Extensions.DependencyInjection;

namespace Generics.OpenRegistration;

public abstract class EntityBase { public Guid Id { get; init; } = Guid.NewGuid(); }
public sealed class Order : EntityBase { }
public sealed class Customer : EntityBase { }

public interface IRepository<T> where T : EntityBase
{
    Task<T?> FindAsync(Guid id, CancellationToken ct);
}

public class Repository<T> : IRepository<T> where T : EntityBase
{
    public virtual Task<T?> FindAsync(Guid id, CancellationToken ct) => Task.FromResult<T?>(null);
}

public sealed class OrderRepository : Repository<Order>
{
    public override Task<Order?> FindAsync(Guid id, CancellationToken ct) => Task.FromResult<Order?>(new Order { Id = id });
}

// Manual decorator without Scrutor, for a closed type
public sealed class LoggingRepository<T>(IRepository<T> inner) : IRepository<T> where T : EntityBase
{
    public async Task<T?> FindAsync(Guid id, CancellationToken ct)
    {
        Console.WriteLine($"Finding {typeof(T).Name} {id}");
        return await inner.FindAsync(id, ct);
    }
}

public static class Program
{
    public static async Task Main()
    {
        var services = new ServiceCollection();
        services.AddScoped(typeof(IRepository<>), typeof(Repository<>));      // open generic
        services.AddScoped<IRepository<Order>, OrderRepository>();            // closed override

        // With Scrutor you could write: services.Decorate(typeof(IRepository<>), typeof(LoggingRepository<>));

        await using var provider = services.BuildServiceProvider(new ServiceProviderOptions
        {
            ValidateOnBuild = true,   // does not cover the open generic
            ValidateScopes = true,
        });
        await using var scope = provider.CreateAsyncScope();

        var orders = scope.ServiceProvider.GetRequiredService<IRepository<Order>>();
        var customers = scope.ServiceProvider.GetRequiredService<IRepository<Customer>>();
        Console.WriteLine(orders.GetType().Name);     // OrderRepository
        Console.WriteLine(customers.GetType().Name);  // Repository`1

        foreach (var repo in scope.ServiceProvider.GetServices<IRepository<Order>>())
            Console.WriteLine($"enumerable: {repo.GetType().Name}");

        var logged = new LoggingRepository<Order>(orders);
        Console.WriteLine((await logged.FindAsync(Guid.NewGuid(), CancellationToken.None))?.Id);
    }
}