Many to many 如何删除实体框架核心中的多对多关系？

我有两个实体框架实体。 1） 雇员 2） 案例

我在实体框架核心中建模了多对多关系

我可以在中添加这样的关系：

    [HttpPost]
    public async Task<Employee> AddCaseEmployee([FromBody]EmployeeCase employeeCase)
    {
        Case lcase = await _caseGenericService.GetSingleIncludingAsync(employeeCase.CaseId);

        lcase.EmployeeCases = new List<EmployeeCase>();
        lcase.EmployeeCases.Add(new EmployeeCase
            {
                CaseId = employeeCase.CaseId,
                EmployeeId = employeeCase.EmployeeId
            }
        );

        await _caseGenericService.UpdateAsync(lcase);

        Employee employee = await _employeeGenericService.GetSingleIncludingAsync(employeeCase.EmployeeId);
        return employee;
    }

    [HttpDelete]
    public async Task<Employee> DeleteCaseEmployee(long employeeId, long caseId)
    {
        Case lcase = await _caseGenericService.GetSingleIncludingAsync(caseId,
            a => a.EmployeeCases);

        //lcase.EmployeeCases.Remove(new EmployeeCase
        //{
        //    CaseId = caseId,
        //    EmployeeId = employeeId
        //}
        //);
        EmployeeCase employeeCase = 
            lcase.EmployeeCases.FirstOrDefault(ec => ec.EmployeeId == employeeId && ec.CaseId == caseId);
        lcase.EmployeeCases.Remove(employeeCase);

        try
        {
            await _caseGenericService.UpdateAsync(lcase);
        }
        catch(Exception ex)
        {

        }

        Employee employee = await _employeeGenericService.GetSingleIncludingAsync(employeeId);
        return employee;
    }

---

如何删除此多对多关系记录？

我最后只使用了原始sql：

    [HttpPost]
    public async Task<Employee> AddCaseEmployee([FromBody]EmployeeCase employeeCase)
    {
        string queryString = "INSERT INTO EmployeeCase VALUES (@EmployeeId, @CaseId)";
        SqlParameter[] sqlParams = new SqlParameter[]
        {
            new SqlParameter { ParameterName = "EmployeeId", Value = employeeCase.EmployeeId },
            new SqlParameter { ParameterName = "CaseId", Value = employeeCase.CaseId },
        };
        _context.Database.ExecuteSqlCommand(queryString, sqlParams);
        Employee employee = await _employeeGenericService.GetSingleIncludingAsync(employeeCase.EmployeeId);

        return employee;
    }

    [Authorize(Roles = "LERSpecialist, Admin")]
    [HttpDelete]
    public async Task<IActionResult> DeleteCaseEmployee(long employeeId, long caseId)
    {

        string queryString = "DELETE FROM EmployeeCase WHERE EmployeeId = @EmployeeId AND CaseId = @CaseId";
        SqlParameter[] sqlParams = new SqlParameter[]
        {
            new SqlParameter { ParameterName = "EmployeeId", Value = employeeId },
            new SqlParameter { ParameterName = "CaseId", Value = caseId },
        };
        _context.Database.ExecuteSqlCommand(queryString, sqlParams);

        return NoContent();
    }

[HttpPost]
公共异步任务AddCaseEmployee（[FromBody]EmployeeCase EmployeeCase）
{
string queryString=“插入EmployeeCase值（@EmployeeId，@CaseId）”；
SqlParameter[]sqlParams=新的SqlParameter[]
{
新的SqlParameter{ParameterName=“EmployeeId”，Value=employeeCase.EmployeeId}，
新的SqlParameter{ParameterName=“CaseId”，Value=employeeCase.CaseId}，
};
_context.Database.ExecuteSqlCommand（queryString，sqlParams）；
Employee-employeeGenericService.GetSingleIncludingAsync（employeeCase.EmployeeId）；
返回员工；
}
[授权（角色=“专家，管理员”）]
[HttpDelete]
公共异步任务DeleteCaseEmployee（长employeeId，长caseId）
{
string queryString=“从EmployeeCase中删除，其中EmployeeId=@EmployeeId和CaseId=@CaseId”；
SqlParameter[]sqlParams=新的SqlParameter[]
{
新的SqlParameter{ParameterName=“EmployeeId”，Value=EmployeeId}，
新的SqlParameter{ParameterName=“CaseId”，Value=CaseId}，
};
_context.Database.ExecuteSqlCommand（queryString，sqlParams）；
返回NoContent（）；
}

我开始倾向于使用实体框架进行查询。（让.Net在查询时为我序列化为JSON。）

---

但是所有其他CRUD（数据操作）都是原始Sql或存储过程。

我遇到了同样的需求，在这里找到了这篇文章。由于真正的解决方案（使用EF）尚未发布，我决定添加以下答案：

另见；这是为了更新，但同样的原则适用于删除

这是我的代码（我的场景是users N↔N组）：

var groupToUpdate=\u userGroupsContext.Groups.Include（g=>g.UserGroups.Single）（u=>u.Id==userVm.groupsIds[0]）；
var userToUpdate=\u userGroupsContext.Users.Single（u=>u.Id==userVm.user.Id）；
groupToUpdate.UserGroups.Remove（groupToUpdate.UserGroups.Where（ugu=>ugu.UserId==userToUpdate.Id）.FirstOrDefault（））；
_userGroupsContext.SaveChanges（）；

---

UserGroups

字段是中间类（表）的列表，其中包含

group

和

groupId

、

user

和

userId

属性；我解决问题的方法是，删除“A”记录时：

因此，当包含B时，EntityFrameworkCore似乎可以自动解决问题。

---

（要使用“Include”别忘了添加“使用Microsoft.EntityFrameworkCore；”）

我必须关闭join对象EmployeeCase的删除，它不能是DbSet。如果不遵循这两个步骤中的任何一个，那么就不会构建多对多模型。为什么？有什么问题吗？正常情况下，它会生成。不知道为什么。你在用Core吗？它通常是内置核心的吗？我是。这是EF Core中相当标准的（也是目前唯一支持的）多对多模型。可能是其他字段（或注释字段）弄乱了某些内容。你可以试着提供一个服务。

public class Employee : BaseEntity
{
    [BindNever]
    public string Email { get; set; }
    [BindNever]
    public long OrganizationId { get; set; }
    [BindNever]
    public string Supervisor { get; set; }
    [BindNever]
    public string SupervisorEmail { get; set; }
    [BindNever]
    public string FirstName { get; set; }
    [BindNever]
    public string LastName { get; set; }
    public string Notes { get; set; }
    [BindNever]
    public  long BargainingUnitId { get; set; }
    [BindNever]
    public long PayPlanId { get; set; }
    [BindNever]
    public long GradeRankId { get; set; }
    [BindNever]
    public long PositionTitleId { get; set; }
    [BindNever]
    public long SeriesId { get; set; }
    public bool IsUnionEmployee { get; set; }
    public virtual Organization Organization { get; set; }
    public virtual BargainingUnit BargainingUnit { get; set; }
    public virtual PayPlan PayPlan { get; set; }
    public virtual GradeRank GradeRank { get; set; }
    public virtual PositionTitle PositionTitle { get; set; }
    public virtual  Series Series { get; set; }
    public virtual ICollection<UnionHours> UnionHours { get; set; }
    [NotMapped]
    public string UnionEmployeeYesNo => (IsUnionEmployee) ? "Yes" : "No";

    public virtual ICollection<EmployeeCase> EmployeeCases { get; set; }

public class Case : BaseEntity
{
    #region Common Case Properties
    public long InitialContactId { get; set; }
    public virtual Employee InitialContact { get; set; }
    [DataType(DataType.Date)]
    public DateTime? InitialConsultDate { get; set; }
    public string LerSpecialistId { get; set; }
    public virtual AppUser LerSpecialist { get; set; }
    public string Notes { get; set; }

    public bool IsDeleted { get; set; }
    public CaseType CaseType { get; set; }
    #endregion

    #region EmployeeCase Properties
    //public long PrimaryEmployeeId { get; set; }
    //public virtual Employee PrimaryEmployee {get;set;}
    public virtual ICollection<EmployeeCase> EmployeeCases { get; set; }
    #endregion

    #region NonEmployeeCase Properties
    //public long PrimaryNonEmployeeId { get; set; }
    //public virtual Employee PrimaryEmployee {get;set;}
    public virtual ICollection<NonEmployeeCase> NonEmployeeCases { get; set; }
    #endregion
}

public class EmployeeCase
{
    [ForeignKey("Id")]
    public long EmployeeId { get; set; }
    public Employee Employee { get; set; }
    [ForeignKey("Id")]
    public long CaseId { get; set; }
    public Case Case { get; set; }

}

    [HttpPost]
    public async Task<Employee> AddCaseEmployee([FromBody]EmployeeCase employeeCase)
    {
        string queryString = "INSERT INTO EmployeeCase VALUES (@EmployeeId, @CaseId)";
        SqlParameter[] sqlParams = new SqlParameter[]
        {
            new SqlParameter { ParameterName = "EmployeeId", Value = employeeCase.EmployeeId },
            new SqlParameter { ParameterName = "CaseId", Value = employeeCase.CaseId },
        };
        _context.Database.ExecuteSqlCommand(queryString, sqlParams);
        Employee employee = await _employeeGenericService.GetSingleIncludingAsync(employeeCase.EmployeeId);

        return employee;
    }

    [Authorize(Roles = "LERSpecialist, Admin")]
    [HttpDelete]
    public async Task<IActionResult> DeleteCaseEmployee(long employeeId, long caseId)
    {

        string queryString = "DELETE FROM EmployeeCase WHERE EmployeeId = @EmployeeId AND CaseId = @CaseId";
        SqlParameter[] sqlParams = new SqlParameter[]
        {
            new SqlParameter { ParameterName = "EmployeeId", Value = employeeId },
            new SqlParameter { ParameterName = "CaseId", Value = caseId },
        };
        _context.Database.ExecuteSqlCommand(queryString, sqlParams);

        return NoContent();
    }

var targetToDelete = await context.A.Include(a =>a.B)                
            .Where(a => a.Id == idToDelte)
            .FirstOrDefaultAsync();
context.A.Remove(targetToDelete );