在.NET ServiceCollection中如何简洁注册深度嵌套的特殊依赖？

方案1：手动构造局部依赖树（简化嵌套写法） #

无需全量嵌套ActivatorUtilities，只针对需要替换的依赖节点手动构造，其余依赖直接从容器获取，逻辑更直观：

services.AddTransient<ICustomerService>(sp =>
{
    // 1. 创建特殊配置的EmailService实例
    var specialEmailService = new EmailService(specialConfigurationString);
    
    // 2. 基于特殊EmailService构造CustomerCreationService（其余依赖自动从容器注入）
    var customCreationService = ActivatorUtilities.CreateInstance<CustomerCreationService>(sp, specialEmailService);
    
    // 3. 基于自定义的CreationService构造ValidationService（其余依赖自动从容器注入）
    var customValidationService = ActivatorUtilities.CreateInstance<CustomerValidationService>(sp, customCreationService);
    
    // 4. 最终构造CustomerService，传入自定义的ValidationService
    return ActivatorUtilities.CreateInstance<CustomerService>(sp, customValidationService);
});

方案2：封装扩展方法实现深层依赖替换 #

如果需要频繁替换深层依赖，可以封装扩展方法，实现类似你期望的CreateInstanceAtAnyLevel的功能，自动递归替换指定类型的依赖：

public static class ServiceProviderExtensions
{
    public static T CreateInstanceWithDeepReplacement<T, TService>(this IServiceProvider sp, TService replacementInstance)
        where TService : class
    {
        var serviceType = typeof(TService);
        var constructor = typeof(T).GetConstructors(BindingFlags.Public | BindingFlags.Instance)
            .OrderByDescending(c => c.GetParameters().Length)
            .First();

        var parameters = new List<object>();
        foreach (var param in constructor.GetParameters())
        {
            if (param.ParameterType == serviceType || param.ParameterType.IsAssignableFrom(serviceType))
            {
                parameters.Add(replacementInstance);
            }
            else
            {
                // 优先从容器获取依赖，容器无匹配则自动构造，同时递归替换该依赖的深层服务
                var paramInstance = sp.GetService(param.ParameterType) 
                    ?? sp.CreateInstanceWithDeepReplacement<object, TService>(replacementInstance);
                parameters.Add(paramInstance);
            }
        }

        return (T)constructor.Invoke(parameters.ToArray());
    }
}

使用时只需一行代码即可完成深层依赖替换：

services.AddTransient<ICustomerService>(sp =>
{
    var specialEmail = new EmailService(specialConfigurationString);
    return sp.CreateInstanceWithDeepReplacement<CustomerService, IEmailService>(specialEmail);
});

方案3：利用命名服务+工厂模式（适合多场景复用） #

如果特殊依赖需要在多个服务中复用，可以先注册命名服务，再通过工厂按需注入：

1. 注册默认与特殊的EmailService：

// 默认EmailService
services.AddTransient<IEmailService, EmailService>();
// 命名的特殊EmailService
services.AddKeyedTransient<IEmailService>("SpecialCustomerEmail", sp => 
    new EmailService(specialConfigurationString));

2. 注册CustomerCreationService的工厂，支持传入指定的EmailService：

services.AddTransient<Func<IEmailService, ICustomerCreationService>>(sp =>
    emailService => ActivatorUtilities.CreateInstance<CustomerCreationService>(sp, emailService));

3. 构造CustomerService时通过工厂获取自定义的CreationService：

services.AddTransient<ICustomerService>(sp =>
{
    var specialEmail = sp.GetRequiredKeyedService<IEmailService>("SpecialCustomerEmail");
    var creationServiceFactory = sp.GetRequiredService<Func<IEmailService, ICustomerCreationService>>();
    var customCreationService = creationServiceFactory(specialEmail);
    
    var customValidationService = ActivatorUtilities.CreateInstance<CustomerValidationService>(sp, customCreationService);
    return ActivatorUtilities.CreateInstance<CustomerService>(sp, customValidationService);
});

内容的提问来源于stack exchange，提问作者Patrick Szalapski