如何注入带有数据库和容器参数的泛型IAzureCosmosDatabaseClient接口？

首先修正你代码里的两处小问题：

1. 构造函数的Logger泛型参数写错了，应该是ILogger<AzureCosmosDatabaseClient<T>>而非ILogger<CosmosDbClient<T>>
2. 构造函数参数应该注入IOptions<CosmosOptions>而非直接注入CosmosOptions
3. 接口的Update方法参数建议和实现类统一为T item，避免不必要的类型转换

接下来提供三种可行的改造方案，按灵活性从低到高排序：

方案1：用.NET内置命名服务注册多实例（推荐.NET 8+） #

第一步：改造AzureCosmosDatabaseClient #

把数据库、容器名从固定配置改为构造函数传入，同时复用全局单例的CosmosClient（它是线程安全的，复用能大幅提升性能）：

public interface IAzureCosmosDatabaseClient<T>
{
    Task<IEnumerable<T>> Query(string query);
    Task Update(string id, T item);
}

public class AzureCosmosDatabaseClient<T> : IAzureCosmosDatabaseClient<T> where T : class
{
    private readonly ILogger<AzureCosmosDatabaseClient<T>> _logger;
    private readonly Container _container;

    public AzureCosmosDatabaseClient(
        ILogger<AzureCosmosDatabaseClient<T>> logger,
        CosmosClient cosmosClient,
        string databaseName,
        string containerName)
    {
        _logger = logger;
        var database = cosmosClient.GetDatabase(databaseName);
        _container = database.GetContainer(containerName);
    }

    public async Task<IEnumerable<T>> Query(string queryText)
    {
        // 原有查询逻辑
        var query = _container.GetItemQueryIterator<T>(new QueryDefinition(queryText));
        var results = new List<T>();
        while (query.HasMoreResults)
        {
            var response = await query.ReadNextAsync();
            results.AddRange(response);
        }
        return results;
    }

    public async Task Update(string id, T item)
    {
        // 原有更新逻辑
        await _container.ReplaceItemAsync(item, id);
    }
}

第二步：注册依赖注入 #

// 注册全局单例CosmosClient
builder.Services.AddSingleton<CosmosClient>(sp =>
{
    var options = sp.GetRequiredService<IOptions<CosmosOptions>>().Value;
    return new CosmosClient(options.CosmosEndpointUrl, options.CosmosPrimaryKey);
});

// 注册User表的客户端，指定命名标识
builder.Services.AddKeyedSingleton<IAzureCosmosDatabaseClient<User>>(
    "UserDb-UserContainer",
    (sp, key) => new AzureCosmosDatabaseClient<User>(
        sp.GetRequiredService<ILogger<AzureCosmosDatabaseClient<User>>>(),
        sp.GetRequiredService<CosmosClient>(),
        "UserDatabase",
        "UserContainer"));

// 注册Order表的客户端，指定另一个命名标识
builder.Services.AddKeyedSingleton<IAzureCosmosDatabaseClient<Order>>(
    "OrderDb-OrderContainer",
    (sp, key) => new AzureCosmosDatabaseClient<Order>(
        sp.GetRequiredService<ILogger<AzureCosmosDatabaseClient<Order>>>(),
        sp.GetRequiredService<CosmosClient>(),
        "OrderDatabase",
        "OrderContainer"));

第三步：使用时注入 #

通过[FromKeyedServices]标记指定要注入的实例：

public class UserService
{
    private readonly IAzureCosmosDatabaseClient<User> _userClient;

    public UserService([FromKeyedServices("UserDb-UserContainer")] IAzureCosmosDatabaseClient<User> userClient)
    {
        _userClient = userClient;
    }
}

方案2：用标记类区分多实例（兼容低版本.NET） #

如果你的项目用的是.NET 7及以下，可以用空标记类来区分不同的客户端实例：

第一步：创建标记类 #

// 标记User相关的Cosmos客户端
public class UserCosmosMarker { }

// 标记Order相关的Cosmos客户端
public class OrderCosmosMarker { }

第二步：改造客户端类 #

新增带标记类的泛型接口和实现：

// 带标记的扩展接口
public interface IAzureCosmosDatabaseClient<T, TMarker> : IAzureCosmosDatabaseClient<T> where TMarker : class { }

// 带标记的实现类
public class AzureCosmosDatabaseClient<T, TMarker> : AzureCosmosDatabaseClient<T>, IAzureCosmosDatabaseClient<T, TMarker>
    where T : class
    where TMarker : class
{
    public AzureCosmosDatabaseClient(
        ILogger<AzureCosmosDatabaseClient<T, TMarker>> logger,
        CosmosClient cosmosClient,
        IOptions<CosmosNamedOptions<TMarker>> options)
        : base(logger, cosmosClient, options.Value.DatabaseName, options.Value.ContainerName)
    {
    }
}

// 新增命名配置类
public class CosmosNamedOptions<TMarker> where TMarker : class
{
    public string DatabaseName { get; set; } = string.Empty;
    public string ContainerName { get; set; } = string.Empty;
}

第三步：配置文件与DI注册 #

在appsettings.json中添加多组配置：

{
  "CosmosRoot": {
    "CosmosEndpointUrl": "你的Cosmos端点",
    "CosmosPrimaryKey": "你的主键"
  },
  "Cosmos:User": {
    "DatabaseName": "UserDatabase",
    "ContainerName": "UserContainer"
  },
  "Cosmos:Order": {
    "DatabaseName": "OrderDatabase",
    "ContainerName": "OrderContainer"
  }
}

注册DI：

// 注册全局CosmosClient
builder.Services.AddSingleton<CosmosClient>(sp =>
{
    var rootOptions = sp.GetRequiredService<IOptions<CosmosOptions>>().Value;
    return new CosmosClient(rootOptions.CosmosEndpointUrl, rootOptions.CosmosPrimaryKey);
});

// 注册User客户端
builder.Services.Configure<CosmosNamedOptions<UserCosmosMarker>>(builder.Configuration.GetSection("Cosmos:User"));
builder.Services.AddSingleton<IAzureCosmosDatabaseClient<User, UserCosmosMarker>, AzureCosmosDatabaseClient<User, UserCosmosMarker>>();
// 适配原接口，方便直接注入
builder.Services.AddSingleton<IAzureCosmosDatabaseClient<User>>(sp => 
    sp.GetRequiredService<IAzureCosmosDatabaseClient<User, UserCosmosMarker>>());

// 注册Order客户端
builder.Services.Configure<CosmosNamedOptions<OrderCosmosMarker>>(builder.Configuration.GetSection("Cosmos:Order"));
builder.Services.AddSingleton<IAzureCosmosDatabaseClient<Order, OrderCosmosMarker>, AzureCosmosDatabaseClient<Order, OrderCosmosMarker>>();
builder.Services.AddSingleton<IAzureCosmosDatabaseClient<Order>>(sp => 
    sp.GetRequiredService<IAzureCosmosDatabaseClient<Order, OrderCosmosMarker>>());

第四步：使用时注入 #

直接注入对应的泛型接口即可：

public class OrderService
{
    private readonly IAzureCosmosDatabaseClient<Order> _orderClient;

    public OrderService(IAzureCosmosDatabaseClient<Order> orderClient)
    {
        _orderClient = orderClient;
    }
}

方案3：工厂模式动态创建（最高灵活性） #

如果需要在运行时动态指定数据库/容器名，可以用工厂模式：

第一步：创建工厂接口与实现 #

public interface ICosmosClientFactory
{
    IAzureCosmosDatabaseClient<T> CreateClient<T>(string databaseName, string containerName) where T : class;
}

public class CosmosClientFactory : ICosmosClientFactory
{
    private readonly IServiceProvider _serviceProvider;
    private readonly CosmosClient _cosmosClient;

    public CosmosClientFactory(IServiceProvider serviceProvider, CosmosClient cosmosClient)
    {
        _serviceProvider = serviceProvider;
        _cosmosClient = cosmosClient;
    }

    public IAzureCosmosDatabaseClient<T> CreateClient<T>(string databaseName, string containerName) where T : class
    {
        var logger = _serviceProvider.GetRequiredService<ILogger<AzureCosmosDatabaseClient<T>>>();
        return new AzureCosmosDatabaseClient<T>(logger, _cosmosClient, databaseName, containerName);
    }
}

第二步：注册工厂 #

builder.Services.AddSingleton<ICosmosClientFactory, CosmosClientFactory>();

第三步：使用工厂创建客户端 #

public class DynamicService
{
    private readonly IAzureCosmosDatabaseClient<User> _userClient;
    private readonly IAzureCosmosDatabaseClient<Order> _orderClient;

    public DynamicService(ICosmosClientFactory factory)
    {
        _userClient = factory.CreateClient<User>("UserDatabase", "UserContainer");
        _orderClient = factory.CreateClient<Order>("OrderDatabase", "OrderContainer");
    }
}

关键注意事项 #

1. 必须复用CosmosClient：CosmosClient是线程安全的，且内部维护了连接池，每次实例化会导致资源浪费和性能下降
2. 避免硬编码参数：数据库/容器名建议从配置文件读取，不要直接写死在代码里
3. 日志泛型要准确：确保Logger的泛型参数和客户端类一致，否则日志会归类错误

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