ASP.NET Core 2.0 WebAPI：通过配置切换仓储实现的最佳设计模式

嘿，针对你在ASP.NET Core 2.0 WebAPI中要实现的「通过配置切换数据存储/消息发送方式」的需求，**策略模式（Strategy Pattern）**绝对是最优解——它完美契合你“基于配置选择不同实现”的核心诉求，再结合ASP.NET Core原生的依赖注入（DI）系统，既能保证代码的扩展性，又完全适配.NET Core的开发模式。

核心思路 #

策略模式的核心是将不同业务逻辑（SQL存储、文件存储、消息队列发送）封装为独立的策略类，同时定义一个统一的接口来约束所有策略的行为。然后通过配置决定在运行时注入哪一个策略实现，控制器只需要依赖统一接口，完全不用关心具体的执行逻辑。

具体实现步骤 #

1. 定义统一策略接口 #

首先创建一个通用接口，约束所有存储/发送操作的行为：

public interface IDataProcessingStrategy
{
    // 可根据业务需求调整参数和返回值
    Task ProcessDataAsync(YourBusinessModel data);
}

注：YourBusinessModel是你实际要处理的业务数据模型，比如订单、用户信息等

2. 实现各个具体策略 #

分别为SQL仓储、文件仓储、消息队列创建对应的策略实现类：

SQL数据库仓储策略

public class SqlStorageStrategy : IDataProcessingStrategy
{
    private readonly YourDbContext _dbContext;

    // 通过DI注入EF Core的DbContext（ASP.NET Core 2.0支持构造函数注入）
    public SqlStorageStrategy(YourDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task ProcessDataAsync(YourBusinessModel data)
    {
        // 实现SQL存储逻辑：添加到DbContext并保存
        _dbContext.YourEntities.Add(data);
        await _dbContext.SaveChangesAsync();
    }
}

文件仓储策略

public class FileStorageStrategy : IDataProcessingStrategy
{
    private readonly IConfiguration _configuration;

    public FileStorageStrategy(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    public async Task ProcessDataAsync(YourBusinessModel data)
    {
        // 从配置读取文件存储路径
        var storagePath = _configuration.GetValue<string>("FileStorage:Path");
        var jsonData = JsonConvert.SerializeObject(data);
        await File.WriteAllTextAsync(Path.Combine(storagePath, $"{Guid.NewGuid()}.json"), jsonData);
    }
}

消息队列发送策略

public class MessageQueueStrategy : IDataProcessingStrategy
{
    private readonly IMessageQueueClient _queueClient; // 假设你有一个消息队列客户端

    public MessageQueueStrategy(IMessageQueueClient queueClient)
    {
        _queueClient = queueClient;
    }

    public async Task ProcessDataAsync(YourBusinessModel data)
    {
        // 实现消息发送逻辑
        var message = new QueueMessage { Data = data, Timestamp = DateTime.UtcNow };
        await _queueClient.SendMessageAsync(message);
    }
}

3. 配置驱动的依赖注入注册 #

在Startup.cs的ConfigureServices方法中，读取配置文件中的存储类型，动态注册对应的策略实现：

首先在appsettings.json中添加配置项：

"DataProcessingSettings": {
    "ProcessingType": "Sql" // 可选值：Sql, File, Queue
}

然后在Startup.cs中注册服务：

public void ConfigureServices(IServiceCollection services)
{
    // 注册其他基础服务（比如DbContext、消息队列客户端等）
    services.AddDbContext<YourDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
    services.AddScoped<IMessageQueueClient, YourMessageQueueClient>();

    // 读取配置中的处理类型
    var processingType = Configuration.GetSection("DataProcessingSettings:ProcessingType").Value;

    // 根据配置注册对应的策略
    switch (processingType?.ToLower())
    {
        case "sql":
            services.AddScoped<IDataProcessingStrategy, SqlStorageStrategy>();
            break;
        case "file":
            services.AddScoped<IDataProcessingStrategy, FileStorageStrategy>();
            break;
        case "queue":
            services.AddScoped<IDataProcessingStrategy, MessageQueueStrategy>();
            break;
        default:
            throw new InvalidOperationException($"不支持的处理类型：{processingType}");
    }

    // 注册WebAPI服务
    services.AddMvc();
}

4. 在控制器中使用策略 #

在你的WebAPI控制器中，通过构造函数注入统一接口，直接调用即可：

[Route("api/[controller]")]
[ApiController]
public class DataController : ControllerBase
{
    private readonly IDataProcessingStrategy _processingStrategy;

    public DataController(IDataProcessingStrategy processingStrategy)
    {
        _processingStrategy = processingStrategy;
    }

    [HttpPost]
    public async Task<IActionResult> PostData([FromBody] YourBusinessModel data)
    {
        if (!ModelState.IsValid)
            return BadRequest(ModelState);

        await _processingStrategy.ProcessDataAsync(data);
        return Ok("数据处理完成");
    }
}

为什么这是最优方案？ #

• 开闭原则友好：如果后续需要新增其他处理方式（比如Redis存储），只需要新增一个实现IDataProcessingStrategy的类，修改配置即可，完全不用改动现有代码
• 配置驱动：不需要重新编译，只要修改appsettings.json就能切换处理逻辑，适配不同的部署环境
• 适配ASP.NET Core 2.0生态：完全利用原生DI系统，不需要额外引入第三方库，学习成本低
• 职责分离清晰：各个处理逻辑都封装在独立的策略类中，控制器只负责接收请求和调用策略，代码可读性和可维护性都很高

进阶优化（可选） #

如果需要运行时动态切换策略（比如根据请求头或参数选择处理方式），可以新增一个策略工厂类：

public interface IDataProcessingStrategyFactory
{
    IDataProcessingStrategy GetStrategy(string processingType);
}

public class DataProcessingStrategyFactory : IDataProcessingStrategyFactory
{
    private readonly IServiceProvider _serviceProvider;

    public DataProcessingStrategyFactory(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public IDataProcessingStrategy GetStrategy(string processingType)
    {
        return processingType?.ToLower() switch
        {
            "sql" => _serviceProvider.GetService<SqlStorageStrategy>(),
            "file" => _serviceProvider.GetService<FileStorageStrategy>(),
            "queue" => _serviceProvider.GetService<MessageQueueStrategy>(),
            _ => throw new InvalidOperationException($"不支持的处理类型：{processingType}")
        };
    }
}

然后在控制器中注入工厂，根据请求参数动态获取策略即可。

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