多版本数据库适配方案咨询：C# WPF应用数据层优化

嘿，这个问题我太有共鸣了——维护多版本数据库的重复代码简直是噩梦！我给你几个经过实践验证的思路，能帮你大幅减少数据层的冗余：

方案1：抽象基类+策略模式（强类型首选） #

核心思路是把公共逻辑抽离到基类，用策略模式处理版本差异，让数据层核心代码完全复用。

步骤拆解： #

1. 定义抽象基类：把所有版本共有的属性（比如Prop1、PropC）放到基类里，版本特有的属性留给子类实现：

public abstract class WidgetBase
{
    public int Id { get; set; }
    public string Prop1 { get; set; }
    public string PropC { get; set; }
}

public class WidgetV1 : WidgetBase
{
    public string Prop2 { get; set; }
}

public class WidgetV2 : WidgetBase
{
    public string Prop3 { get; set; }
    public string PropD { get; set; }
}

2. 创建版本策略接口：定义处理版本特有逻辑的契约，比如实体类型获取、版本字段映射、特殊操作等：

public interface IWidgetStrategy
{
    Type GetEntityType();
    WidgetDto MapToDto(WidgetBase entity);
    void MapDtoToEntity(WidgetDto dto, WidgetBase entity);
}

// V1版本策略实现
public class WidgetV1Strategy : IWidgetStrategy
{
    public Type GetEntityType() => typeof(WidgetV1);
    
    public WidgetDto MapToDto(WidgetBase entity)
    {
        var v1Entity = (WidgetV1)entity;
        return new WidgetDto
        {
            Id = v1Entity.Id,
            Prop1 = v1Entity.Prop1,
            PropC = v1Entity.PropC,
            VersionSpecificValue = v1Entity.Prop2
        };
    }

    public void MapDtoToEntity(WidgetDto dto, WidgetBase entity)
    {
        var v1Entity = (WidgetV1)entity;
        v1Entity.Prop2 = dto.VersionSpecificValue;
    }
}

// V2版本策略实现
public class WidgetV2Strategy : IWidgetStrategy
{
    public Type GetEntityType() => typeof(WidgetV2);
    
    public WidgetDto MapToDto(WidgetBase entity)
    {
        var v2Entity = (WidgetV2)entity;
        return new WidgetDto
        {
            Id = v2Entity.Id,
            Prop1 = v2Entity.Prop1,
            PropC = v2Entity.PropC,
            VersionSpecificValue = v2Entity.Prop3,
            ExtraProp = v2Entity.PropD
        };
    }

    public void MapDtoToEntity(WidgetDto dto, WidgetBase entity)
    {
        var v2Entity = (WidgetV2)entity;
        v2Entity.Prop3 = dto.VersionSpecificValue;
        v2Entity.PropD = dto.ExtraProp;
    }
}

3. 通用数据层仓储：依赖策略接口，核心增删查逻辑完全复用，只在需要处理版本差异时调用策略：

public class WidgetRepository
{
    private readonly DbContext _dbContext;
    private readonly IWidgetStrategy _strategy;

    public WidgetRepository(DbContext dbContext, IWidgetStrategy strategy)
    {
        _dbContext = dbContext;
        _strategy = strategy;
    }

    public async Task<WidgetDto> GetByIdAsync(int id)
    {
        var entity = await _dbContext.FindAsync(_strategy.GetEntityType(), id);
        return _strategy.MapToDto((WidgetBase)entity);
    }

    public async Task AddAsync(WidgetDto dto)
    {
        var entity = (WidgetBase)Activator.CreateInstance(_strategy.GetEntityType());
        // 映射公共属性
        entity.Id = dto.Id;
        entity.Prop1 = dto.Prop1;
        entity.PropC = dto.PropC;
        // 版本特有属性交给策略处理
        _strategy.MapDtoToEntity(dto, entity);

        _dbContext.Add(entity);
        await _dbContext.SaveChangesAsync();
    }
}

切换数据库版本时，只需要注入对应的IWidgetStrategy实现即可，完全不用修改仓储的核心逻辑。

方案2：EF Core动态模型配置（适合用EF的场景） #

如果你的项目用Entity Framework Core，可以直接在DbContext里根据当前数据库版本动态配置实体模型，这样甚至可以用同一个实体类（或基类）适配不同版本的表。

示例代码： #

public class AppDbContext : DbContext
{
    private readonly string _dbVersion;

    public AppDbContext(DbContextOptions<AppDbContext> options, IConfiguration config) 
        : base(options)
    {
        _dbVersion = config["DbVersion"]; // 从配置读取当前版本，比如V1/V2
    }

    public DbSet<WidgetBase> Widgets { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        var widgetEntity = modelBuilder.Entity<WidgetBase>();
        // 配置公共属性
        widgetEntity.HasKey(x => x.Id);
        widgetEntity.Property(x => x.Prop1).IsRequired();
        widgetEntity.Property(x => x.PropC).IsRequired();

        // 根据版本配置特有属性
        if (_dbVersion == "V2")
        {
            widgetEntity.Property<string>("Prop3"); // 用阴影属性或在基类定义可选属性
            widgetEntity.Property<string>("PropD");
        }
        else if (_dbVersion == "V1")
        {
            widgetEntity.Property<string>("Prop2");
        }

        widgetEntity.ToTable("Widget");
    }
}

这种方式的好处是不用定义多个实体类，数据层方法直接用WidgetBase操作，版本差异完全在模型配置里处理。如果属性差异不大（只是多几列），这个方案最简洁。

方案3：泛型仓储+版本工厂（简化泛型选择逻辑） #

你已经尝试了泛型方案，那可以再封装一个版本仓储工厂，把“根据版本选泛型类型”的逻辑集中起来，避免在业务层到处判断版本。

示例代码： #

public interface IWidgetRepository<T> where T : WidgetBase
{
    Task<T> GetByIdAsync(int id);
    Task AddAsync(T entity);
    // 其他通用方法
}

public class GenericWidgetRepository<T> : IWidgetRepository<T> where T : WidgetBase
{
    private readonly DbContext _dbContext;

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

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

    public async Task AddAsync(T entity)
    {
        _dbContext.Add(entity);
        await _dbContext.SaveChangesAsync();
    }
}

// 版本仓储工厂
public static class WidgetRepositoryFactory
{
    public static IWidgetRepository<WidgetBase> GetRepository(DbContext dbContext, string dbVersion)
    {
        return dbVersion switch
        {
            "V1" => new GenericWidgetRepository<WidgetV1>(dbContext) as IWidgetRepository<WidgetBase>,
            "V2" => new GenericWidgetRepository<WidgetV2>(dbContext) as IWidgetRepository<WidgetBase>,
            _ => throw new NotSupportedException($"Unsupported DB version: {dbVersion}")
        };
    }
}

业务层使用时，只需要调用工厂方法：

var repository = WidgetRepositoryFactory.GetRepository(dbContext, currentDbVersion);
var widget = await repository.GetByIdAsync(1);
// 转交给前端DTO处理

这个方案保留了泛型的强类型优势，同时把版本判断逻辑集中在工厂里，避免代码散落在各处。

方案4：动态对象+反射（适合简单场景） #

如果你的版本差异极小，且不想定义多个实体类，可以用dynamic或ExpandoObject配合反射来处理，虽然失去了强类型检查，但能减少类的数量。

示例代码（读取数据）： #

public async Task<WidgetDto> GetWidgetByIdAsync(int id, string dbVersion)
{
    var sql = dbVersion switch
    {
        "V1" => "SELECT Id, Prop1, Prop2, PropC FROM Widget WHERE Id = @Id",
        "V2" => "SELECT Id, Prop1, Prop3, PropC, PropD FROM Widget WHERE Id = @Id",
        _ => throw new NotSupportedException()
    };

    var dynamicWidget = await _dbContext.QueryFirstOrDefaultAsync<dynamic>(sql, new { Id = id });
    var dto = new WidgetDto();
    
    // 反射映射公共属性
    var commonProps = typeof(WidgetDto).GetProperties().Where(p => p.Name is "Id" or "Prop1" or "PropC");
    foreach (var prop in commonProps)
    {
        prop.SetValue(dto, dynamicWidget.GetType().GetProperty(prop.Name)?.GetValue(dynamicWidget));
    }

    // 处理版本特有属性
    if (dbVersion == "V1")
    {
        dto.VersionSpecificValue = dynamicWidget.Prop2;
    }
    else if (dbVersion == "V2")
    {
        dto.VersionSpecificValue = dynamicWidget.Prop3;
        dto.ExtraProp = dynamicWidget.PropD;
    }

    return dto;
}

这个方案适合快速实现，但缺点是编译时没有类型检查，后期维护成本较高，只推荐在差异极小且项目规模不大的情况下使用。

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