ASP.NET Code-First迁移中如何访问模型已删但数据库仍存的字段？

当然有办法！除了写纯SQL，你可以利用EF的原始查询能力或者临时数据模型来安全迁移数据，下面是几个实用的方案：

方案一：用原始SQL查询结合值类型/匿名类型接收数据 #

你可以直接通过EF的数据库查询API获取包含旧字段的结果，不用依赖当前模型。这种方式简洁高效，适合快速处理：

EF Core 示例 #

public partial class MigrateFooBarToManyToMany : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        // 1. 先创建多对多连接表
        migrationBuilder.CreateTable(
            name: "FooBar",
            columns: table => new
            {
                FoosId = table.Column<int>(type: "int", nullable: false),
                BarsId = table.Column<int>(type: "int", nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_FooBar", x => new { x.FoosId, x.BarsId });
                table.ForeignKey(
                    name: "FK_FooBar_Foos_FoosId",
                    column: x => x.FoosId,
                    principalTable: "Foos",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
                table.ForeignKey(
                    name: "FK_FooBar_Bars_BarsId",
                    column: x => x.BarsId,
                    principalTable: "Bars",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        // 2. 查询旧字段数据并迁移
        using (var context = new MyApplicationContext())
        {
            // 用值元组接收查询结果
            var fooBarPairs = context.Database.SqlQuery<(int FooId, int BarId)>(
                "SELECT Id AS FooId, BarId FROM Foos WHERE BarId IS NOT NULL").ToList();

            foreach (var pair in fooBarPairs)
            {
                var foo = context.Foos.Find(pair.FooId);
                var bar = context.Bars.Find(pair.BarId);
                if (foo != null && bar != null)
                {
                    foo.Bars.Add(bar);
                }
            }
            context.SaveChanges();
        }

        // 3. 最后删除旧的外键和字段
        migrationBuilder.DropForeignKey(
            name: "FK_Foos_Bars_BarId",
            table: "Foos");
        migrationBuilder.DropIndex(
            name: "IX_Foos_BarId",
            table: "Foos");
        migrationBuilder.DropColumn(
            name: "BarId",
            table: "Foos");
    }

    // Down 方法省略...
}

EF6 示例 #

public partial class MigrateFooBarToManyToMany : DbMigration
{
    public override void Up()
    {
        // 创建多对多表
        CreateTable(
            "dbo.FooBars",
            c => new
                {
                    FooId = c.Int(nullable: false),
                    BarId = c.Int(nullable: false),
                })
            .PrimaryKey(t => new { t.FooId, t.BarId })
            .ForeignKey("dbo.Foos", t => t.FooId, cascadeDelete: true)
            .ForeignKey("dbo.Bars", t => t.BarId, cascadeDelete: true)
            .Index(t => t.FooId)
            .Index(t => t.BarId);

        using (var context = new MyApplicationContext())
        {
            var fooBarPairs = context.Database.SqlQuery<Tuple<int, int>>(
                "SELECT Id, BarId FROM Foos WHERE BarId IS NOT NULL").ToList();

            foreach (var pair in fooBarPairs)
            {
                var foo = context.Foos.Find(pair.Item1);
                var bar = context.Bars.Find(pair.Item2);
                if (foo != null && bar != null)
                {
                    foo.Bars.Add(bar);
                }
            }
            context.SaveChanges();
        }

        // 删除旧字段
        DropForeignKey("dbo.Foos", "BarId", "dbo.Bars");
        DropIndex("dbo.Foos", new[] { "BarId" });
        DropColumn("dbo.Foos", "BarId");
    }

    // Down 方法省略...
}

方案二：在迁移类中定义临时数据模型 #

如果想要强类型的安全保障，可以在迁移文件内部定义一个临时类，专门用来映射数据库中还存在的旧字段。这个类只在迁移中生效，不会影响你的主模型：

public partial class MigrateFooBarToManyToMany : DbMigration
{
    // 临时类，仅用于本次迁移
    private class TempFoo
    {
        public int Id { get; set; }
        public int? BarId { get; set; }
    }

    public override void Up()
    {
        // 1. 创建多对多表
        CreateTable(
            "dbo.FooBars",
            c => new
                {
                    FooId = c.Int(nullable: false),
                    BarId = c.Int(nullable: false),
                })
            .PrimaryKey(t => new { t.FooId, t.BarId })
            .ForeignKey("dbo.Foos", t => t.FooId, cascadeDelete: true)
            .ForeignKey("dbo.Bars", t => t.BarId, cascadeDelete: true)
            .Index(t => t.FooId)
            .Index(t => t.BarId);

        // 2. 用临时类查询并迁移数据
        using (var context = new MyApplicationContext())
        {
            var tempFoos = context.Database.SqlQuery<TempFoo>("SELECT Id, BarId FROM Foos").ToList();
            foreach (var tempFoo in tempFoos.Where(f => f.BarId.HasValue))
            {
                var foo = context.Foos.Find(tempFoo.Id);
                var bar = context.Bars.Find(tempFoo.BarId.Value);
                if (foo != null && bar != null)
                {
                    foo.Bars.Add(bar);
                }
            }
            context.SaveChanges();
        }

        // 3. 清理旧字段
        DropForeignKey("dbo.Foos", "BarId", "dbo.Bars");
        DropIndex("dbo.Foos", new[] { "BarId" });
        DropColumn("dbo.Foos", "BarId");
    }

    // Down 方法省略...
}

关键注意事项 #

• 迁移顺序很重要：一定要先创建多对多的连接表，再迁移数据，最后删除旧的外键和字段，避免数据丢失。
• 空值处理：记得判断BarId是否为空，避免空引用异常。
• 测试迁移：在生产环境运行前，一定要在测试环境验证迁移逻辑，确保数据正确迁移。

内容的提问来源于stack exchange，提问作者Zeust the Unoobian