Entity Framework Core + SQLite保存列表对象时出现跟踪冲突错误

你的报错核心是EF Core的上下文跟踪机制：同一DbContext实例中，不允许同时跟踪两个具有相同主键的实体对象。当你给InValue和OutValue列表分别添加ValueId相同的不同Value实例时，EF会将它们视为两个独立实体，但主键重复，因此触发InvalidOperationException。而单个实例时，上下文只跟踪一个对象，自然不会有冲突。

1. 复用同一Value实例（优先推荐） #

不要为同一个ValueId创建多个Value对象，而是复用同一个实例添加到两个列表中：

// 先获取或创建目标Value实例（确保上下文只跟踪一个）
var sharedValue = context.Values.FirstOrDefault(v => v.ValueId == 1) 
                  ?? new Value { ValueId = 1, /* 其他属性赋值 */ };

// 如果是新创建的实例，先添加到上下文（可选，SaveChanges时会自动处理）
if (sharedValue.ValueId == 0)
{
    context.Values.Add(sharedValue);
}

// 创建Format并复用同一个Value实例
var testFormat = new Format();
testFormat.InValue.Add(sharedValue);
testFormat.OutValue.Add(sharedValue);

context.Formats.Add(testFormat);
context.SaveChanges(); // 不再报错

2. 修正模型关系配置 #

根据你的业务场景，选择对应的关系配置：

场景A：Format与Value是两个独立的一对多关系 #

如果Value只能属于一个Format的InValue或OutValue（不能同时属于两者），需要在Value类中添加两个外键属性：

public class Value
{
    public int ValueId { get; set; }
    // 对应InValue的外键
    public int? InFormatId { get; set; }
    public Format? InFormat { get; set; }
    // 对应OutValue的外键
    public int? OutFormatId { get; set; }
    public Format? OutFormat { get; set; }
}

public class Format
{
    public int FormatId { get; set; }
    public ICollection<Value> InValue { get; set; } = new List<Value>();
    public ICollection<Value> OutValue { get; set; } = new List<Value>();
}

然后在OnModelCreating中显式配置关系：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 配置InValue关系
    modelBuilder.Entity<Format>()
        .HasMany(f => f.InValue)
        .WithOne(v => v.InFormat)
        .HasForeignKey(v => v.InFormatId)
        .OnDelete(DeleteBehavior.Restrict); // 避免级联删除冲突

    // 配置OutValue关系
    modelBuilder.Entity<Format>()
        .HasMany(f => f.OutValue)
        .WithOne(v => v.OutFormat)
        .HasForeignKey(v => v.OutFormatId)
        .OnDelete(DeleteBehavior.Restrict);
}

场景B：Format与Value是多对多关系（支持共享Value） #

如果业务允许同一个Value被多个Format的In/Out列表引用，或者同一个Format的两个列表共享同一个Value，需要使用多对多关系，通过连接实体实现：

// 连接实体：Format与InValue的关联
public class FormatInValue
{
    public int FormatId { get; set; }
    public Format Format { get; set; } = null!;
    public int ValueId { get; set; }
    public Value Value { get; set; } = null!;
}

// 连接实体：Format与OutValue的关联
public class FormatOutValue
{
    public int FormatId { get; set; }
    public Format Format { get; set; } = null!;
    public int ValueId { get; set; }
    public Value Value { get; set; } = null!;
}

// 主实体调整
public class Format
{
    public int FormatId { get; set; }
    public ICollection<FormatInValue> InValue { get; set; } = new List<FormatInValue>();
    public ICollection<FormatOutValue> OutValue { get; set; } = new List<FormatOutValue>();
}

public class Value
{
    public int ValueId { get; set; }
    public ICollection<FormatInValue> FormatsAsIn { get; set; } = new List<FormatInValue>();
    public ICollection<FormatOutValue> FormatsAsOut { get; set; } = new List<FormatOutValue>();
}

然后配置Fluent API：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 配置FormatInValue的复合主键
    modelBuilder.Entity<FormatInValue>()
        .HasKey(fiv => new { fiv.FormatId, fiv.ValueId });

    modelBuilder.Entity<FormatInValue>()
        .HasOne(fiv => fiv.Format)
        .WithMany(f => f.InValue)
        .HasForeignKey(fiv => fiv.FormatId);

    modelBuilder.Entity<FormatInValue>()
        .HasOne(fiv => fiv.Value)
        .WithMany(v => v.FormatsAsIn)
        .HasForeignKey(fiv => fiv.ValueId);

    // 配置FormatOutValue的复合主键
    modelBuilder.Entity<FormatOutValue>()
        .HasKey(fov => new { fov.FormatId, fov.ValueId });

    modelBuilder.Entity<FormatOutValue>()
        .HasOne(fov => fov.Format)
        .WithMany(f => f.OutValue)
        .HasForeignKey(fov => fov.FormatId);

    modelBuilder.Entity<FormatOutValue>()
        .HasOne(fov => fov.Value)
        .WithMany(v => v.FormatsAsOut)
        .HasForeignKey(fov => fov.ValueId);
}

初始化数据时，通过连接实体关联：

var sharedValue = new Value { ValueId = 1, /* 其他属性 */ };
context.Values.Add(sharedValue);

var testFormat = new Format();
testFormat.InValue.Add(new FormatInValue { Value = sharedValue });
testFormat.OutValue.Add(new FormatOutValue { Value = sharedValue });

context.Formats.Add(testFormat);
context.SaveChanges();

• 确保Value类的ValueId被正确配置为主键（EF默认会识别ValueId为主键，但显式配置更可靠：modelBuilder.Entity<Value>().HasKey(v => v.ValueId);）
• 避免在初始化时创建多个相同主键的实体实例，始终复用同一个对象或先从上下文查询已存在的实例

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