C#依赖注入：如何初始化构造函数注入的服务及相关疑问

1. 如何调用特定构造函数初始化注入的服务？ #

DI容器默认会自动选择参数匹配度最高的构造函数，但如果要强制指定某一个构造函数，核心思路是手动控制实例创建逻辑，再注册到容器中。

以.NET为例：

// 假设服务类有两个构造函数
public class MyService : IMyService
{
    public MyService() { }
    public MyService(string configParam) { }
}

// 在DI注册时，用工厂方法指定调用带参数的构造函数
services.AddSingleton<IMyService>(sp => 
{
    // 可从容器中获取其他依赖，再传入目标构造函数
    var config = sp.GetRequiredService<IConfiguration>();
    var param = config["MyService:ConfigParam"];
    return new MyService(param); // 明确调用带参数的构造函数
});

Java Spring场景：

@Configuration
public class AppConfig {
    @Bean
    public MyService myService() {
        // 手动调用指定构造函数创建实例
        return new MyService("customParam");
    }
}

2. 通过两个不同构造函数初始化服务的两个独立实例 #

要实现这个需求，需要给不同实例标记唯一标识，然后分别注册到容器中，注入时根据标识选择对应实例。

以.NET 6+的Keyed服务为例：

// 注册两个不同实例，分别调用不同构造函数
services.AddKeyedSingleton<IMyService>("InstanceA", sp => new MyService()); // 调用无参构造
services.AddKeyedSingleton<IMyService>("InstanceB", sp => new MyService("specialParam")); // 调用带参构造

// 注入时指定标识
public class MyConsumer
{
    private readonly IMyService _instanceA;
    private readonly IMyService _instanceB;

    public MyConsumer([FromKeyedServices("InstanceA")] IMyService instanceA,
                     [FromKeyedServices("InstanceB")] IMyService instanceB)
    {
        _instanceA = instanceA;
        _instanceB = instanceB;
    }
}

Java Spring场景：

@Configuration
public class AppConfig {
    @Bean("instanceA")
    public MyService instanceA() {
        return new MyService(); // 无参构造
    }

    @Bean("instanceB")
    public MyService instanceB() {
        return new MyService("specialParam"); // 带参构造
    }
}

// 注入时通过@Qualifier选择
public class MyConsumer {
    @Autowired
    @Qualifier("instanceA")
    private MyService instanceA;

    @Autowired
    @Qualifier("instanceB")
    private MyService instanceB;
}

3. 是否可以在应用类构造函数之外初始化注入的类？ #

完全可以，常见的实现方式有几种：

• 属性注入：直接在类的属性上标记注入注解（注意：部分框架不推荐属性注入，可能导致空引用，需确保容器已初始化实例）

  // .NET示例（需启用属性注入，比如在ASP.NET Core中配置）
  public class MyConsumer
  {
      [Inject]
      public IMyService? MyService { get; set; }
  
      public void DoWork()
      {
          MyService?.Execute(); // 使用前需判空
      }
  }
  

• 手动从容器获取：在需要的地方直接从服务提供者（ServiceProvider/ApplicationContext）中获取实例

  // .NET示例
  public void SomeMethod(IServiceProvider serviceProvider)
  {
      var myService = serviceProvider.GetRequiredService<IMyService>();
      myService.Execute();
  }
  

• 方法注入：在方法参数上标记注入，框架会自动传入实例

  // Spring示例
  public class MyConsumer {
      private MyService myService;
  
      @Autowired
      public void setMyService(MyService myService) {
          this.myService = myService;
      }
  
      public void doWork() {
          myService.execute();
      }
  }
  

• 延迟注入：用Lazy<T>包装，在首次使用时才初始化实例

  public class MyConsumer
  {
      private readonly Lazy<IMyService> _lazyMyService;
  
      public MyConsumer(Lazy<IMyService> lazyMyService)
      {
          _lazyMyService = lazyMyService;
      }
  
      public void DoWork()
      {
          var service = _lazyMyService.Value; // 此时才初始化实例
          service.Execute();
      }
  }
  

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