C#中带构造函数参数的类如何实现依赖注入？场景优化咨询

首先给出你提供的代码（修正了语法问题）：

public interface ISomeClient { }

public class SomeClient : ISomeClient
{
    private readonly string _clientID;
    private readonly string _clientSecret;

    public SomeClient(string clientID, string clientSecret)
    {
        _clientID = clientID;
        _clientSecret = clientSecret;
    }
}

public class SomeWrapper
{
    private readonly ISomeClient _someClient;

    public SomeWrapper(ISomeClient someClient)
    {
        _someClient = someClient;
    }
}

针对你提出的四种方案，结合「保持类分离、让SomeWrapper易于使用」的需求，分析如下：

方案分析与推荐 #

1. 实例化SomeWrapper时直接传入参数 #

这种方案要求用户手动创建SomeClient实例并传入SomeWrapper，示例代码：

var client = new SomeClient("id", "secret");
var wrapper = new SomeWrapper(client);

劣势：用户需要知晓SomeClient的构造参数细节，违背了依赖注入「解耦」的核心目的，增加代码耦合度，不推荐。

2. 创建工厂类（推荐） #

通过工厂封装SomeClient的实例化逻辑，用户只需通过工厂获取ISomeClient或直接获取SomeWrapper，无需关心构造参数。

示例实现：

// 定义工厂接口
public interface ISomeClientFactory
{
    ISomeClient Create(string clientID, string clientSecret);
    // 也可以直接创建Wrapper
    SomeWrapper CreateWrapper(string clientID, string clientSecret);
}

// 工厂实现
public class SomeClientFactory : ISomeClientFactory
{
    public ISomeClient Create(string clientID, string clientSecret)
    {
        return new SomeClient(clientID, clientSecret);
    }

    public SomeWrapper CreateWrapper(string clientID, string clientSecret)
    {
        var client = Create(clientID, clientSecret);
        return new SomeWrapper(client);
    }
}

用户使用时只需调用工厂方法：

var factory = new SomeClientFactory();
var wrapper = factory.CreateWrapper("id", "secret");

优势：完全保持类分离，隐藏了SomeClient的构造细节，用户只需关注SomeWrapper的使用，符合依赖注入的设计原则。

3. 构造函数外通过独立方法传入参数 #

即通过属性或初始化方法设置clientID和clientSecret，示例代码：

public class SomeClient : ISomeClient
{
    private string _clientID;
    private string _clientSecret;

    public void Initialize(string clientID, string clientSecret)
    {
        _clientID = clientID;
        _clientSecret = clientSecret;
    }
}

劣势：会导致SomeClient处于未初始化的无效状态，若用户忘记调用Initialize会引发运行时错误，破坏对象完整性，不推荐。

4. 合并两个类 #

直接违背你「保持类分离」的前提，完全不可取。

结合DI容器的进阶方案 #

如果你的项目使用了.NET自带的依赖注入容器（如Microsoft.Extensions.DependencyInjection），可以直接在服务注册时绑定配置参数，无需手动创建工厂：

1. 在配置文件（如appsettings.json）中添加参数：

{
  "ClientSettings": {
    "ClientID": "your-client-id",
    "ClientSecret": "your-client-secret"
  }
}

2. 在服务注册时注入ISomeClient：

var builder = WebApplication.CreateBuilder(args);

// 注册ISomeClient，从配置中读取参数
builder.Services.AddScoped<ISomeClient>(sp =>
{
    var config = sp.GetRequiredService<IConfiguration>();
    var clientId = config["ClientSettings:ClientID"] ?? throw new InvalidOperationException("ClientID未配置");
    var clientSecret = config["ClientSettings:ClientSecret"] ?? throw new InvalidOperationException("ClientSecret未配置");
    return new SomeClient(clientId, clientSecret);
});

// 注册SomeWrapper
builder.Services.AddScoped<SomeWrapper>();

3. 用户使用时直接注入SomeWrapper即可：

public class SomeService
{
    private readonly SomeWrapper _wrapper;

    public SomeService(SomeWrapper wrapper)
    {
        _wrapper = wrapper;
    }
}

优势：完全自动化管理依赖，用户无需手动处理任何实例化逻辑，代码最简洁，适合大多数.NET项目场景。

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