.NET分层架构下解决Azure TableClient泛型跨层依赖问题

针对分层架构中应用层与Azure存储解耦的问题，提供以下三种可行方案：

方案一：应用层定义自有实体抽象，基础设施层实现双接口实体 #

核心思路是在应用层定义独立于Azure的表实体抽象接口，基础设施层的实体同时实现该抽象和Azure的ITableEntity接口，既满足应用层的抽象依赖，又适配Azure存储的要求。

应用层代码 #

// 应用层独立定义表实体的必要属性抽象
public interface IAppTableEntity
{
    string PartitionKey { get; set; }
    string RowKey { get; set; }
    DateTimeOffset? Timestamp { get; set; }
    ETag ETag { get; set; }
}

// 应用层存储接口，约束为自有抽象，完全不依赖Azure包
public interface ITableStorage
{
    Task SaveItemsAsync<T>(IEnumerable<T> entities, string tableName = nameof(T)) where T : IAppTableEntity;
}

基础设施层代码 #

// 业务实体同时实现应用层抽象和Azure的ITableEntity
public class CustomerEntity : IAppTableEntity, ITableEntity
{
    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public DateTimeOffset? Timestamp { get; set; }
    public ETag ETag { get; set; }

    // 自定义业务字段
    public string Name { get; set; }
    public int Age { get; set; }
}

// 存储实现，增加Azure接口的约束（仅在基础设施层可见）
public class AzureTableStorage : ITableStorage
{
    private readonly TableServiceClient _tableServiceClient;

    public AzureTableStorage(TableServiceClient tableServiceClient)
    {
        _tableServiceClient = tableServiceClient;
    }

    public async Task SaveItemsAsync<T>(IEnumerable<T> entities, string tableName = nameof(T)) 
        where T : IAppTableEntity, ITableEntity
    {
        var tableClient = _tableServiceClient.GetTableClient(tableName);
        await tableClient.CreateIfNotExistsAsync();

        foreach (var entity in entities)
        {
            await tableClient.UpsertEntityAsync(entity);
        }
    }
}

优点：实现简单，实体仅依赖接口，耦合度低；缺点：实体需要实现两个接口，少量增加实体定义成本。

方案二：通过映射器实现应用层实体与Azure实体的转换 #

核心思路是应用层完全使用独立业务实体，基础设施层定义适配Azure的实体类，通过映射工具（如AutoMapper）完成两者的转换，彻底隔离Azure依赖。

应用层代码 #

// 应用层纯业务实体，无任何Azure相关依赖
public class Customer
{
    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

// 应用层存储接口，无泛型约束
public interface ITableStorage
{
    Task SaveItemsAsync<T>(IEnumerable<T> entities, string tableName = nameof(T));
}

基础设施层代码 #

// 适配Azure存储的实体类，实现ITableEntity
public class CustomerTableEntity : ITableEntity
{
    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public DateTimeOffset? Timestamp { get; set; }
    public ETag ETag { get; set; }

    public string Name { get; set; }
    public int Age { get; set; }
}

// 存储实现，通过映射器转换实体
public class AzureTableStorage : ITableStorage
{
    private readonly TableServiceClient _tableServiceClient;
    private readonly IMapper _mapper;

    public AzureTableStorage(TableServiceClient tableServiceClient, IMapper mapper)
    {
        _tableServiceClient = tableServiceClient;
        _mapper = mapper;
    }

    public async Task SaveItemsAsync<T>(IEnumerable<T> entities, string tableName = nameof(T))
    {
        var tableClient = _tableServiceClient.GetTableClient(tableName);
        await tableClient.CreateIfNotExistsAsync();

        foreach (var entity in entities)
        {
            var tableEntity = _mapper.Map<ITableEntity>(entity);
            await tableClient.UpsertEntityAsync(tableEntity);
        }
    }
}

// AutoMapper映射配置
public class TableEntityProfile : Profile
{
    public TableEntityProfile()
    {
        CreateMap<Customer, CustomerTableEntity>();
        // 可添加其他实体的映射规则
    }
}

优点：应用层与Azure完全解耦，实体定义纯净；缺点：需要维护映射配置，增加少量复杂度。

方案三：使用泛型适配器包装应用层实体 #

核心思路是通过一个泛型适配器类实现ITableEntity，同时持有应用层实体的引用，无需修改应用层实体即可适配Azure存储。

应用层代码 #

// 应用层纯业务实体
public class Customer
{
    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

public interface ITableStorage
{
    Task SaveItemsAsync<T>(IEnumerable<T> entities, string tableName = nameof(T));
}

基础设施层代码 #

// 泛型适配器，实现ITableEntity并包装应用层实体
public class TableEntityAdapter<T> : ITableEntity
{
    public T BusinessEntity { get; set; }

    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public DateTimeOffset? Timestamp { get; set; }
    public ETag ETag { get; set; }

    public TableEntityAdapter(T entity, string partitionKey, string rowKey)
    {
        BusinessEntity = entity;
        PartitionKey = partitionKey;
        RowKey = rowKey;
    }
}

// 存储实现，通过适配器包装应用层实体
public class AzureTableStorage : ITableStorage
{
    private readonly TableServiceClient _tableServiceClient;

    public AzureTableStorage(TableServiceClient tableServiceClient)
    {
        _tableServiceClient = tableServiceClient;
    }

    public async Task SaveItemsAsync<T>(IEnumerable<T> entities, string tableName = nameof(T))
    {
        var tableClient = _tableServiceClient.GetTableClient(tableName);
        await tableClient.CreateIfNotExistsAsync();

        foreach (var entity in entities)
        {
            // 反射获取实体的PartitionKey和RowKey（也可通过应用层定义简单接口避免反射）
            var partitionKey = entity.GetType().GetProperty(nameof(TableEntityAdapter<T>.PartitionKey))?.GetValue(entity) as string;
            var rowKey = entity.GetType().GetProperty(nameof(TableEntityAdapter<T>.RowKey))?.GetValue(entity) as string;

            if (string.IsNullOrEmpty(partitionKey) || string.IsNullOrEmpty(rowKey))
                throw new ArgumentException("实体必须包含PartitionKey和RowKey属性");

            var adapter = new TableEntityAdapter<T>(entity, partitionKey, rowKey);
            await tableClient.UpsertEntityAsync(adapter);
        }
    }
}

优点：无需修改应用层实体，适配灵活；缺点：反射获取属性有轻微性能损耗，可通过应用层定义IPartitionRowKey接口替代反射优化。

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