如何避免多对多表重复插入？EF Core实践方案合理性咨询

问题背景 #

我有Article和Tag两个实体，是多对多关系，最初的实体定义如下：

public class Article : AuditableBaseEntity
{
    public string Title { get; set; }

    public string Content { get; set; }

    public virtual ICollection<ArticleTag> ArticleTags { get; set;} 
}

public class Tag : AuditableBaseEntity
{
    public string Name { get; set; }

    public virtual ICollection<ArticleTag> ArticleTags { get; set;} 
}

原本使用以下方法为已有文章添加已有标签：

public async Task<Article> AddExistingTagToArticle(Article article, Tag tag, CancellationToken cancellationToken)
{
    ArticleTag articleTag = new(article, tag);

    article.ArticleTags.Add(articleTag);
    tag.ArticleTags.Add(articleTag);

    _context.ArticleTags.Add(articleTag);

    await _context.SaveChangesAsync(cancellationToken);

    return article;
}

但重复添加同一ArticleTag时，出现了**"无法跟踪，因为存在另一具有相同Id的ArticleTag实例正在被跟踪"**的错误，而非预期的主键冲突DbUpdate错误。

之后我将ICollection<ArticleTag> ArticleTags改为HashSet<ArticleTag> ArticleTags，在C#层面避免重复插入，修改后的方法如下：

public async Task<Article> AddExistingTagToArticle(Article article, Tag tag, CancellationToken cancellationToken)
{
    ArticleTag articleTag = new(article, tag);

    bool isAlreadyExists = !article.ArticleTags.Add(articleTag);

    if(isAlreadyExists){
         return article;
    }

    tag.ArticleTags.Add(articleTag);

    _context.ArticleTags.Add(articleTag);

    await _context.SaveChangesAsync(cancellationToken);

    return article;
}

这个方案解决了问题，但我想知道：

1. 这种做法是否正确？
2. 是否存在设计问题？
3. 这类场景通常的处理方式是什么？

解答 #

1. 这种做法是否正确？ #

你的做法是正确且合理的：

• 用HashSet替代默认的List实现ICollection，结合正确的相等性判断，能在内存层面快速识别重复关联，避免不必要的数据库操作，性能比依赖数据库异常更高。
• 提前在业务层拦截重复请求，规避了EF Core的跟踪冲突问题，逻辑更可控。

2. 是否存在设计问题？ #

需要注意几个关键细节，否则可能导致方案失效：

• 必须正确实现ArticleTag的相等性：HashSet的去重逻辑依赖Equals和GetHashCode方法，你需要基于ArticleId和TagId（关联表的复合主键）来重写这些方法，否则HashSet无法识别重复的关联项：

  public class ArticleTag : AuditableBaseEntity
  {
      public Guid ArticleId { get; set; }
      public Guid TagId { get; set; }
      public Article Article { get; set; }
      public Tag Tag { get; set; }
  
      public ArticleTag(Article article, Tag tag)
      {
          ArticleId = article.Id;
          TagId = tag.Id;
          Article = article;
          Tag = tag;
      }
  
      public override bool Equals(object obj)
      {
          if (obj is not ArticleTag other) return false;
          return ArticleId == other.ArticleId && TagId == other.TagId;
      }
  
      public override int GetHashCode()
      {
          return HashCode.Combine(ArticleId, TagId);
      }
  }
  

• 确保实体的跟踪状态一致：如果article和tag是从同一个上下文加载的跟踪实体，你的逻辑没问题；如果是脱离上下文的实体（比如从DTO转换而来），需要先将其附加到上下文，否则可能出现跟踪冲突。
• 双向关联维护的必要性：同时给article.ArticleTags和tag.ArticleTags添加关联项，能保证内存中对象图的一致性，这在EF Core中是合理的，但要注意后续查询时双向关联的状态同步。

3. 这类场景通常的处理方式？ #

常见处理方式有以下几种，可根据业务场景选择：

• 内存层面拦截（你的方案）：适合高频操作场景，性能最优，前提是确保HashSet和相等性逻辑正确。
• 数据库约束兜底：无论业务层是否做拦截，都要给ArticleTag表创建复合主键（ArticleId, TagId），确保数据库层面不会出现重复数据，作为最后一道防线。
• 查询检查后插入：如果内存中的实体集合可能不完整（比如实体是脱离上下文的状态），可以先查询数据库判断关联是否存在：

  var exists = await _context.ArticleTags
      .AnyAsync(at => at.ArticleId == article.Id && at.TagId == tag.Id, cancellationToken);
  if (exists) return article;
  // 执行插入逻辑
  

  这种方式兼容性更强，但多了一次数据库查询，性能略差。
• EF Core隐式多对多（无中间实体）：如果关联表没有额外字段，EF Core 5+支持无需显式定义ArticleTag的多对多关系，框架会自动处理关联去重：

  public class Article : AuditableBaseEntity
  {
      public string Title { get; set; }
      public string Content { get; set; }
      public virtual ICollection<Tag> Tags { get; set; } = new HashSet<Tag>();
  }
  
  public class Tag : AuditableBaseEntity
  {
      public string Name { get; set; }
      public virtual ICollection<Article> Articles { get; set; } = new HashSet<Article>();
  }
  

  此时添加标签只需article.Tags.Add(tag)，EF Core会自动判断关联是否存在，无需手动处理中间实体。

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