如何在遵循SOLID原则的C# EF项目中集成外部数据源？

既然你已经在遵循SOLID原则，核心思路是不破坏现有分层结构，通过抽象隔离外部数据源与业务逻辑，以下是具体落地步骤：

1. 抽象通用数据访问接口（遵循依赖倒置原则） #

先定义一个与数据源无关的通用数据访问接口，让EF实现和API实现都基于这个接口。这样上层业务服务只依赖抽象，不关心数据来自数据库还是外部API。

// 通用数据访问接口，根据你的业务需求增减方法
public interface IEntityRepository<T> where T : class
{
    Task<IEnumerable<T>> GetAllAsync();
    Task<T?> GetByIdAsync(int id);
    // 如果需要向API提交数据，可添加CreateAsync/UpdateAsync等方法
}

你的现有EF持久化层应该已经实现了这个接口（如果之前没抽象，现在补上即可），比如：

public class EfEntityRepository<T> : IEntityRepository<T> where T : class
{
    private readonly DbContext _dbContext;

    public EfEntityRepository(DbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<IEnumerable<T>> GetAllAsync()
    {
        return await _dbContext.Set<T>().ToListAsync();
    }

    public async Task<T?> GetByIdAsync(int id)
    {
        return await _dbContext.Set<T>().FindAsync(id);
    }
}

2. 实现外部API的数据访问类（遵循单一职责原则） #

新建一个专门负责调用外部API的实现类，只处理HTTP请求、响应解析和错误处理，不掺杂其他逻辑。

public class ApiEntityRepository<T> : IEntityRepository<T> where T : class
{
    private readonly HttpClient _httpClient;
    private readonly string _apiEndpoint;
    private readonly ILogger<ApiEntityRepository<T>> _logger;

    // 通过构造函数注入HttpClient和日志组件
    public ApiEntityRepository(HttpClient httpClient, string apiEndpoint, ILogger<ApiEntityRepository<T>> logger)
    {
        _httpClient = httpClient;
        _apiEndpoint = apiEndpoint;
        _logger = logger;
    }

    public async Task<IEnumerable<T>> GetAllAsync()
    {
        try
        {
            var response = await _httpClient.GetAsync(_apiEndpoint);
            response.EnsureSuccessStatusCode();
            return await response.Content.ReadFromJsonAsync<IEnumerable<T>>() ?? Enumerable.Empty<T>();
        }
        catch (HttpRequestException ex)
        {
            _logger.LogError(ex, "Failed to fetch all entities from external API");
            throw; // 可封装成自定义异常抛给上层处理
        }
    }

    public async Task<T?> GetByIdAsync(int id)
    {
        try
        {
            var response = await _httpClient.GetAsync($"{_apiEndpoint}/{id}");
            
            if (response.StatusCode == HttpStatusCode.NotFound)
            {
                _logger.LogInformation("Entity with ID {Id} not found in external API", id);
                return null;
            }
            
            response.EnsureSuccessStatusCode();
            return await response.Content.ReadFromJsonAsync<T>();
        }
        catch (HttpRequestException ex)
        {
            _logger.LogError(ex, "Failed to fetch entity with ID {Id} from external API", id);
            throw;
        }
    }
}

3. 依赖注入配置 #

在项目的DI容器中注册API实现，同时配置HttpClient的基础地址、请求头，还可以添加重试策略处理API临时故障（需引入Polly包）。

// Program.cs 或 Startup.cs
builder.Services.AddHttpClient<IEntityRepository<YourExternalModel>, ApiEntityRepository<YourExternalModel>>(client =>
{
    client.BaseAddress = new Uri("https://your-external-api-base-url.com/");
    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
    // 如果API需要认证，添加请求头，比如：
    // client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "your-token");
})
// 可选：添加重试策略，处理API 5xx/4xx错误
.AddPolicyHandler(GetRetryPolicy());

// 重试策略实现
static IAsyncPolicy<HttpResponseMessage> GetRetryPolicy()
{
    return Policy
        .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
        .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
}

// 同时保留EF实现的注册（针对本地实体）
builder.Services.AddScoped<IEntityRepository<YourLocalEntity>, EfEntityRepository<YourLocalEntity>>();

4. 模型映射（可选） #

如果外部API返回的模型和你的本地模型结构不一致，不要直接修改现有模型，用AutoMapper做映射：

1. 定义映射配置：

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<ExternalApiResponseModel, YourLocalModel>();
        // 如果需要向API提交数据，添加反向映射
        CreateMap<YourLocalModel, ExternalApiRequestModel>();
    }
}

2. 在API repository中注入IMapper并完成映射：

private readonly IMapper _mapper;

public ApiEntityRepository(HttpClient httpClient, string apiEndpoint, ILogger<ApiEntityRepository<T>> logger, IMapper mapper)
{
    _httpClient = httpClient;
    _apiEndpoint = apiEndpoint;
    _logger = logger;
    _mapper = mapper;
}

public async Task<IEnumerable<YourLocalModel>> GetAllAsync()
{
    var apiModels = await _httpClient.GetFromJsonAsync<IEnumerable<ExternalApiResponseModel>>(_apiEndpoint);
    return _mapper.Map<IEnumerable<YourLocalModel>>(apiModels);
}

5. 业务层无感知调用 #

你的业务服务类原本依赖IEntityRepository<T>，现在不需要做任何修改，DI容器会自动注入对应的实现（EF或API）：

public class YourBusinessService
{
    private readonly IEntityRepository<YourExternalModel> _externalRepo;
    private readonly IEntityRepository<YourLocalEntity> _localRepo;

    public YourBusinessService(IEntityRepository<YourExternalModel> externalRepo, IEntityRepository<YourLocalEntity> localRepo)
    {
        _externalRepo = externalRepo;
        _localRepo = localRepo;
    }

    public async Task DoBusinessLogicAsync()
    {
        var externalData = await _externalRepo.GetAllAsync();
        var localData = await _localRepo.GetAllAsync();
        // 业务逻辑处理
    }
}

这样做的好处：

• 符合单一职责原则：EF层只处理数据库，API层只处理外部请求
• 符合依赖倒置原则：业务层依赖抽象而非具体实现
• 扩展性强：后续新增其他数据源（比如Redis），只需要新增对应的IEntityRepository<T>实现即可
• 易于测试：可以用Mock对象替代真实API调用做单元测试

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