EF Core复杂关系级联删除报错：实现预期行为并解决循环路径问题

问题根源 #

SQL Server不允许多条级联删除路径指向同一个表。你的场景中，删除Country时存在多条路径会触发Flight的删除：

• Country → Airline → Flight
• Country → Airport → Flight（出发/到达机场两条子路径）
  这种多路径冲突导致了报错。

解决方案 #

我们需要调整级联删除配置，同时手动处理部分删除逻辑，既满足业务需求，又规避SQL Server的限制。

步骤1：修改EF Core关系配置 #

将Flight与DepartureAirport、ArrivalAirport的级联删除改为Restrict（阻止数据库自动级联），保留Airline→Flight、Country→Airline、Country→Airport的级联配置：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    base.OnModelCreating(modelBuilder);

    modelBuilder.Entity<Airline>(x =>
    {
        x.HasKey(a => a.Id);
        x.HasOne(c => c.Country)
            .WithMany(a => a.Airlines)
            .HasForeignKey(a => a.CountryId)
            .OnDelete(DeleteBehavior.Cascade)
            .IsRequired();
    });

    modelBuilder.Entity<Airport>(x =>
    {
        x.HasKey(a => a.Id);
        x.HasOne(c => c.Country)
            .WithMany(a => a.Airports)
            .HasForeignKey(a => a.CountryId)
            .OnDelete(DeleteBehavior.Cascade)
            .IsRequired();
    });

    modelBuilder.Entity<Country>(x => x.HasKey(c => c.Id));

    modelBuilder.Entity<Flight>(x =>
    {
        x.HasKey(f => f.Id);

        // 保留Airline到Flight的级联删除
        x.HasOne(a => a.Airline)
            .WithMany(f => f.Flights)
            .HasForeignKey(f => f.AirlineId)
            .OnDelete(DeleteBehavior.Cascade)
            .IsRequired();

        // 修改为Restrict，避免多路径冲突
        x.HasOne(a => a.DepartureAirport)
            .WithMany(f => f.DepartureFlights)
            .HasForeignKey(f => f.DepartureAirportId)
            .OnDelete(DeleteBehavior.Restrict)
            .IsRequired();

        x.HasOne(a => a.ArrivalAirport)
            .WithMany(f => f.ArrivalFlights)
            .HasForeignKey(f => f.ArrivalAirportId)
            .OnDelete(DeleteBehavior.Restrict)
            .IsRequired();
    });
}

步骤2：手动处理删除逻辑 #

根据业务需求，补充以下删除操作的逻辑：

删除Country时

需要先删除所有关联的Flight，再删除Country（此时Airline和Airport会被自动级联删除）：

public async Task DeleteCountryAsync(int countryId)
{
    var country = await _context.Countries
        .Include(c => c.Airlines)
            .ThenInclude(a => a.Flights)
        .Include(c => c.Airports)
            .ThenInclude(a => a.DepartureFlights)
        .Include(c => c.Airports)
            .ThenInclude(a => a.ArrivalFlights)
        .FirstOrDefaultAsync(c => c.Id == countryId);

    if (country == null) return;

    // 收集所有关联的Flight并删除
    var allFlights = new List<Flight>();
    country.Airlines?.ForEach(a => allFlights.AddRange(a.Flights ?? Enumerable.Empty<Flight>()));
    country.Airports?.ForEach(a => 
    {
        allFlights.AddRange(a.DepartureFlights ?? Enumerable.Empty<Flight>());
        allFlights.AddRange(a.ArrivalFlights ?? Enumerable.Empty<Flight>());
    });

    _context.Flights.RemoveRange(allFlights.Distinct());
    _context.Countries.Remove(country);

    await _context.SaveChangesAsync();
}

删除Airport时

需要先删除该机场关联的所有出发/到达航班，再删除机场：

public async Task DeleteAirportAsync(int airportId)
{
    var airport = await _context.Airports
        .Include(a => a.DepartureFlights)
        .Include(a => a.ArrivalFlights)
        .FirstOrDefaultAsync(a => a.Id == airportId);

    if (airport == null) return;

    _context.Flights.RemoveRange(airport.DepartureFlights ?? Enumerable.Empty<Flight>());
    _context.Flights.RemoveRange(airport.ArrivalFlights ?? Enumerable.Empty<Flight>());
    _context.Airports.Remove(airport);

    await _context.SaveChangesAsync();
}

删除Airline时

无需额外处理，因为Airline→Flight的级联已配置，直接删除Airline会自动删除关联的Flight：

public async Task DeleteAirlineAsync(int airlineId)
{
    var airline = await _context.Airlines.FindAsync(airlineId);
    if (airline == null) return;

    _context.Airlines.Remove(airline);
    await _context.SaveChangesAsync();
}

验证效果 #

• 删除Country：先删除所有关联的Flight，再自动级联删除Airline和Airport
• 删除Airline：自动级联删除关联的Flight
• 删除Airport：先删除关联的出发/到达Flight，再删除机场
• 数据库层面不再存在多路径级联冲突，可正常生成迁移并更新数据库

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