为您的课程添加关系

    public partial class Member
    {
        public Member()
        {
            MemberMembers = new HashSet<MemberRecruit>();
            MemberRecruits = new HashSet<MemberRecruit>();
        }

        [Key]
        public int id { get; set; }
        public String Name { get; set; }

       

        [InverseProperty(nameof(MemberRecruit.Member))]
        public virtual ICollection<MemberRecruit> MemberRecruits { get; set; }

        [InverseProperty(nameof(MemberRecruit.Recruit))]
        public virtual ICollection<MemberRecruit> MemberMembers { get; set; }
    }
        public partial class MemberRecruit
        {
            [Key]
            public int id { get; set; }
            public int RecruitId { get; set; }
            public int MemberId { get; set; }

            [ForeignKey(nameof(MemberId))]
            [InverseProperty("MemberRecruits")]
            public virtual Member Member { get; set; }

            [ForeignKey(nameof(RecruitId))]
            [InverseProperty("MemberMembers")]
            public virtual Member Recruit { get; set; }
        }

和 dbcontext

        public virtual DbSet<Member> Members{ get; set; }
        public virtual DbSet<MemberRecruit> MemberRecruits { get; set; }

        protected override void OnModelCreaTing(ModelBuilder modelBuilder)
        {
          modelBuilder.Entity<MemberRecruit>(entity =>
            {
                entity.HasOne(d => d.Member)
                    .WithMany(p => p.MemberRecruits)
                    .HasForeignKey(d => d.MemberId)
                    .ondelete(deleteBehavior.ClientSetnull);


                entity.HasOne(d => d.Recruit)
                    .WithMany(p => p.MemberMembers)
                    .HasForeignKey(d => d.RecruitId);

            });

由于任何成员都可能是另一个成员的新成员和另一个新成员的成员，因此它有 2 个虚拟集合 - 1 个显示他是另一个新成员的记录（在 memberId 部分），第二个显示他是另一个新成员的记录招募另一个成员（在recruitId 部分）。因此，如果您想查看会员的所有招聘人员，您可以通过两种方式进行

var recruiters=context.MemberRecruits
.Where(i=> i.MemberId==memberId)
.SELEct(i=>i.Recruit)
.ToList();
//or 
var recruits = _context.Members
.Where(i => i.Id == memberId)
.SELEct(i => i.MemberRecruits.SELEct(j => j.Recruit)).FirstOrDefault();

第二个查询看起来有点奇怪，但您应该明白，members 的意思是 member 是 member，recruss - where member 是招聘人员。也许更好地重命名集合“AsMember”和“AsRecruiter”。由你决定。 由于查询 MemberRecruit 容易得多，我建议使用它进行查询。 另一个例子。 memberId 是招聘人员的成员

var members=context.MemberRecruits
.Where(i=> i.RecruitEID==memberId)
.SELEct(i=>i.Member)
.ToList();

如果您想使用第二个选项，根据 MS Docs Single navigation property，您可以通过使用 Fluent API 定义这样的关系来设置导航属性。

给定以下类

public class Member
{
   public int id { get; set; }
   public String Name { get; set; }
   public IList<Member> Recruitments { get; set; }
}

protected override void OnModelCreaTing(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Member>()
        .Hasmany(b => b.Member)
        .WithOne();
}

更新

给定以下类

public class Member
{
   [Key]
   public int id { get; set; }
   public String Name { get; set; }
   public IList<MemberRecruit> Recruitments { get; set; }
}

public class MemberRecruit
{
   [Key]
   public int id { get; set; }
   public int RecruitmentMemberId { get; set; }
   public Member RecruitmentMember { get; set; }
}

protected override void OnModelCreaTing(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Member>()
        .Hasmany(b => b.MemberRecruit)
        .WithOne();

    modelBuilder.Entity<MemberRecruit>()
        .HasOne(b => b.RecruitmentMember)
        .WithOne();
}

你应该可以这样查询

var memeber = context.Member
              .Include(x => x.Recruitments)
              .FirstOrDefaultAsync(x => x.Id == request.Id);

var memberRecruitments = member.Recruitments
                         .SELEct(x => new Member 
                         {
                              Id = x.Id,Name = x.Name 
                         }).ToList();

不确定这是否是最佳做法，但以下有效

public class Member
{
   public int id { get; set; }
   public String Name { get; set; }
   public IList<MemberRecruit> Recruits { get; set; }
}

public class MemberRecruit
{
   public int MemberId { get; set; }
   public int RecruitmentMemberId { get; set; }
   public Member Recruitment { get; set; } // This is the recruited member
}

数据库上下文

builder.Entity<Member>(m =>
{
    m.@R_10_10586@ble("Member","dbo");
    m.HasKey(x => x.Id);

    m.Hasmany(x => x.Recruits)
        .WithOne()
        .HasForeignKey(mr => mr.MemberId);
});

builder.Entity<MemberRecruit>(m =>
{
    m.@R_10_10586@ble("MemberRecruit","dbo");
    m.HasKey(x => new
    {
        x.MemberId,x.RecruitmentMemberId
    });

    m.HasOne(x => x.Recruitment)
        .WithOne()
        .HasForeignKey<Member>(x => x.Id)
        .HasPrincipalKey<MemberRecruit>(x => x.RecruitmentMemberId);
});

查询和结果

var member = await _db.Members
                .AsnoTracking()
                .Include(x => x.Recruits)
                .ThenInclude(x => x.Recruitment)
                .FirstOrDefaultAsync(x => x.Id == request.Id,token);
// If request.Id == 1
// member.Recruits.Count is 2
// member.Recruits[0].Recruitment will be (2,"Steve")
// member.Recruits[1].Recruitment will be (3,"Bruce")