如何基于EF Core 6实现标准好友关系结构？

问题分析 #

• 第一种自关联多对多方案无效，是因为EF Core无法自动识别自关联的隐式多对多关系，需显式配置；即便配置完成，默认仍会存储双向关系（两行数据）。
• 第二种显式中间表方案的核心问题是未添加约束与业务逻辑控制，导致需手动插入两行数据，冗余且不符合规范。

解决方案：单条存储的好友关系实现 #

1. 修正实体类设计 #

保留显式中间表，明确复合主键，不设置反向导航属性（避免自动生成双向关系）：

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public string Email { get; set; }

    // 关联中间表的导航属性
    public ICollection<PersonFriend>? FriendRelations { get; set; }
}

public class PersonFriend
{
    public int PersonId { get; set; }
    public Person Person { get; set; }

    public int FriendId { get; set; }
    public Person Friend { get; set; }
}

2. Fluent API配置 #

在DbContext中配置关系、复合主键和数据库约束，确保关系唯一且仅存一条：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 配置PersonFriend的复合主键
    modelBuilder.Entity<PersonFriend>()
        .HasKey(pf => new { pf.PersonId, pf.FriendId });

    // 配置Person到PersonFriend的正向关系
    modelBuilder.Entity<PersonFriend>()
        .HasOne(pf => pf.Person)
        .WithMany(p => p.FriendRelations)
        .HasForeignKey(pf => pf.PersonId)
        .OnDelete(DeleteBehavior.Restrict); // 防止级联删除引发的问题

    // 配置Friend到Person的反向关系，不设置导航属性
    modelBuilder.Entity<PersonFriend>()
        .HasOne(pf => pf.Friend)
        .WithMany()
        .HasForeignKey(pf => pf.FriendId)
        .OnDelete(DeleteBehavior.Restrict);

    // 添加数据库检查约束：确保PersonId < FriendId，避免重复存储同一关系
    modelBuilder.Entity<PersonFriend>()
        .HasCheckConstraint("CK_PersonFriend_PersonIdLessThanFriendId", "PersonId < FriendId");
}

3. 业务逻辑控制 #

添加好友时，通过逻辑确保仅插入一条符合约束的记录：

public void AddFriend(Person person1, Person person2)
{
    if (person1.Id == person2.Id)
        throw new InvalidOperationException("无法添加自己为好友");

    // 检查关系是否已存在（双向都要检查）
    bool exists = _context.PersonFriends.Any(pf => 
        (pf.PersonId == person1.Id && pf.FriendId == person2.Id) || 
        (pf.PersonId == person2.Id && pf.FriendId == person1.Id));

    if (exists) return;

    // 按照约束存储：小Id在前，大Id在后
    var relation = new PersonFriend
    {
        PersonId = Math.Min(person1.Id, person2.Id),
        FriendId = Math.Max(person1.Id, person2.Id)
    };

    _context.PersonFriends.Add(relation);
    _context.SaveChanges();
}

4. 好友查询逻辑 #

查询时同时匹配PersonId和FriendId，获取完整的好友列表：

public IEnumerable<Person> GetFriends(Person person)
{
    // 提取所有关联的好友Id
    var friendIds = _context.PersonFriends
        .Where(pf => pf.PersonId == person.Id || pf.FriendId == person.Id)
        .Select(pf => pf.PersonId == person.Id ? pf.FriendId : pf.PersonId);

    // 查询对应的Person实体
    return _context.People.Where(p => friendIds.Contains(p.Id)).ToList();
}

为什么不推荐隐式多对多？ #

EF Core 5及以上支持隐式多对多（无需显式中间表），但自关联的隐式多对多默认会存储双向关系（A→B和B→A各一条），无法通过配置避免重复数据，因此对于需要单条存储的好友关系场景，显式中间表+约束的方案更合适。

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