EF Core中RemoteContext实例创建失败，数据库迁移报错求助

一、迁移报错原因及修复 #

EF Core的设计时工具（如Add-Migration或dotnet ef migrations add）需要能无参数实例化DbContext，或通过特定机制获取上下文实例。你的RemoteContext仅提供带connectionString参数的构造函数，工具无法自动生成所需参数，因此抛出无法创建对象的错误。

修复方案1：添加设计时上下文工厂 #

创建实现IDesignTimeDbContextFactory<RemoteContext>的类，让EF Core在设计时通过该工厂获取上下文实例：

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Design;

public class RemoteContextFactory : IDesignTimeDbContextFactory<RemoteContext>
{
    public RemoteContext CreateDbContext(string[] args)
    {
        // 填入开发/测试环境的SQL Server连接字符串
        var connectionString = "Server=.;Database=PwManagerRemote;Trusted_Connection=True;";
        return new RemoteContext(connectionString);
    }
}

将该类放在项目根目录或EF Core可扫描到的位置，设计时工具会自动识别。

修复方案2：添加设计时专用无参数构造函数 #

给RemoteContext添加无参数构造函数，仅用于设计时迁移：

public class RemoteContext : DbContext
{
    public DbSet<Password> Passwords { get; set; }
    public DbSet<Group> Groups { get; set; }

    private string _ConnectionString { get; }

    // 设计时专用无参数构造函数
    public RemoteContext()
    {
        _ConnectionString = "Server=.;Database=PwManagerRemote;Trusted_Connection=True;";
    }

    public RemoteContext(string connectionString)
    {
        _ConnectionString = connectionString;
    }

    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseSqlServer(_ConnectionString);

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        _ = modelBuilder.ApplyConfiguration(new PasswordConfig());
        _ = modelBuilder.ApplyConfiguration(new GroupConfig());
    }
}

注意：该构造函数仅用于迁移操作，运行时仍使用带参数的构造函数传入正式环境连接字符串。

二、数据同步的优化方案 #

直接使用两个DbContext可行，但可通过以下方式优化：

1. 复用实体配置与DbSet定义 #

抽象基类避免重复代码：

public abstract class BaseContext : DbContext
{
    public DbSet<Password> Passwords { get; set; }
    public DbSet<Group> Groups { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        _ = modelBuilder.ApplyConfiguration(new PasswordConfig());
        _ = modelBuilder.ApplyConfiguration(new GroupConfig());
    }
}

// 本地上下文
public class ApplicationContext : BaseContext
{
    public string DbPath { get; }

    public ApplicationContext()
    {
        var path = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
        DbPath = Path.Join(path, "pwmanager.db");
    }

    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseSqlite($"Data Source={DbPath}");
}

// 远程上下文
public class RemoteContext : BaseContext
{
    private string _ConnectionString { get; }

    public RemoteContext(string connectionString)
    {
        _ConnectionString = connectionString;
    }

    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseSqlServer(_ConnectionString);
}

2. 增量同步逻辑实现 #

避免全量同步，基于LastModified字段做增量更新，同时用事务保证一致性：

public class DataSyncService
{
    private readonly ApplicationContext _localContext;
    private readonly RemoteContext _remoteContext;

    public DataSyncService(ApplicationContext localContext, RemoteContext remoteContext)
    {
        _localContext = localContext;
        _remoteContext = remoteContext;
    }

    public async Task SyncRemoteToLocalAsync()
    {
        using var transaction = await _localContext.Database.BeginTransactionAsync();
        try
        {
            // 同步Groups
            var remoteGroups = await _remoteContext.Groups.ToListAsync();
            foreach (var remoteGroup in remoteGroups)
            {
                var localGroup = await _localContext.Groups.FindAsync(remoteGroup.Id);
                if (localGroup == null)
                {
                    _localContext.Groups.Add(remoteGroup);
                }
                else if (remoteGroup.LastModified > localGroup.LastModified)
                {
                    _localContext.Entry(localGroup).CurrentValues.SetValues(remoteGroup);
                }
            }

            // 同步Passwords
            var remotePasswords = await _remoteContext.Passwords.ToListAsync();
            foreach (var remotePw in remotePasswords)
            {
                var localPw = await _localContext.Passwords.FindAsync(remotePw.Id);
                if (localPw == null)
                {
                    _localContext.Passwords.Add(remotePw);
                }
                else if (remotePw.LastModified > localPw.LastModified)
                {
                    _localContext.Entry(localPw).CurrentValues.SetValues(remotePw);
                }
            }

            await _localContext.SaveChangesAsync();
            await transaction.CommitAsync();
        }
        catch
        {
            await transaction.RollbackAsync();
            throw;
        }
    }
}

3. 依赖注入与启动同步 #

在Program.cs中注册服务并启动时执行同步：

builder.Services.AddDbContext<ApplicationContext>();
builder.Services.AddDbContext<RemoteContext>(options => 
{
    var connectionString = builder.Configuration.GetConnectionString("RemoteSqlServer");
    options.UseSqlServer(connectionString);
});
builder.Services.AddScoped<DataSyncService>();

var app = builder.Build();

// 启动时异步执行数据同步
using (var scope = app.Services.CreateScope())
{
    var syncService = scope.ServiceProvider.GetRequiredService<DataSyncService>();
    await syncService.SyncRemoteToLocalAsync();
}

// 后续中间件配置
app.Run();

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