如何在EF Core中避免相似多对多关联类的重复代码？

完全可以通过泛型+接口的方式实现代码复用，既保留现有实体结构，又避免重复编写逻辑。以下是具体实现步骤：

1. 抽象关联实体的ID获取能力 #

给Enrollment和Club定义一个通用接口，统一获取主键的方式，让泛型代码无需关心具体的ID属性名：

public interface IEntityWithId
{
    int GetEntityId();
}

// Enrollment实现接口
public class Enrollment : IEntityWithId
{
    public int EnrollmentId { get; set; }
    public string EnrollmentName { get; set; }

    public int GetEntityId() => EnrollmentId;
}

// Club实现接口
public class Club : IEntityWithId
{
    public int ClubId { get; set; }
    public string ClubName { get; set; }

    public int GetEntityId() => ClubId;
}

2. 创建泛型基类封装通用逻辑 #

定义抽象泛型基类，包含通用的StudentId、关联实体ID属性，以及通用的AddStudent方法。同时抽象出数据库查询、实例创建等细节，由子类实现具体逻辑：

public abstract class StudentAssociationBase<T> where T : IEntityWithId
{
    public int StudentId { get; set; }
    // 通用关联ID属性，后续通过EF配置映射到实际列名
    public virtual int AssociatedEntityId { get; set; }

    public void AddStudent(Student student, T associatedEntity)
    {
        var entityId = associatedEntity.GetEntityId();
        if (!Exists(sa => sa.AssociatedEntityId == entityId && sa.StudentId == student.StudentId))
        {
            var newAssociation = CreateNewInstance(student.StudentId, entityId);
            AddToContext(newAssociation);
        }
    }

    // 抽象方法：子类实现关联是否存在的查询逻辑
    protected abstract bool Exists(Func<StudentAssociationBase<T>, bool> predicate);
    // 抽象方法：子类创建关联实例
    protected abstract StudentAssociationBase<T> CreateNewInstance(int studentId, int entityId);
    // 抽象方法：子类将实例添加到DbContext
    protected abstract void AddToContext(StudentAssociationBase<T> association);
}

3. 实现具体的关联类 #

让StudentEnrollment和StudentClub继承泛型基类，实现抽象方法，并通过EF特性指定数据库列名：

// StudentEnrollment实现
public class StudentEnrollment : StudentAssociationBase<Enrollment>
{
    // 映射到数据库的EnrollmentId列
    [Column("EnrollmentId")]
    public override int AssociatedEntityId { get; set; }

    protected override bool Exists(Func<StudentAssociationBase<Enrollment>, bool> predicate)
    {
        using var context = new YourDbContext();
        return context.StudentEnrollments.Any(predicate);
    }

    protected override StudentAssociationBase<Enrollment> CreateNewInstance(int studentId, int entityId)
    {
        return new StudentEnrollment { StudentId = studentId, AssociatedEntityId = entityId };
    }

    protected override void AddToContext(StudentAssociationBase<Enrollment> association)
    {
        using var context = new YourDbContext();
        context.StudentEnrollments.Add((StudentEnrollment)association);
        context.SaveChanges();
    }
}

// StudentClub实现
public class StudentClub : StudentAssociationBase<Club>
{
    // 映射到数据库的ClubId列
    [Column("ClubId")]
    public override int AssociatedEntityId { get; set; }

    protected override bool Exists(Func<StudentAssociationBase<Club>, bool> predicate)
    {
        using var context = new YourDbContext();
        return context.StudentClubs.Any(predicate);
    }

    protected override StudentAssociationBase<Club> CreateNewInstance(int studentId, int entityId)
    {
        return new StudentClub { StudentId = studentId, AssociatedEntityId = entityId };
    }

    protected override void AddToContext(StudentAssociationBase<Club> association)
    {
        using var context = new YourDbContext();
        context.StudentClubs.Add((StudentClub)association);
        context.SaveChanges();
    }
}

替代方案：静态泛型服务类 #

如果不想用继承，也可以把通用逻辑封装到静态服务类中，直接传入DbContext和DbSet操作：

public static class StudentAssociationService
{
    public static void AddStudent<T>(YourDbContext context, Student student, T associatedEntity, DbSet<StudentAssociation<T>> dbSet)
        where T : IEntityWithId
    {
        var entityId = associatedEntity.GetEntityId();
        if (!dbSet.Any(sa => sa.AssociatedEntityId == entityId && sa.StudentId == student.StudentId))
        {
            var newAssociation = Activator.CreateInstance<StudentAssociation<T>>();
            newAssociation.StudentId = student.StudentId;
            newAssociation.AssociatedEntityId = entityId;
            dbSet.Add(newAssociation);
            context.SaveChanges();
        }
    }
}

// 泛型关联实体类
public class StudentAssociation<T> where T : IEntityWithId
{
    public int StudentId { get; set; }
    public virtual int AssociatedEntityId { get; set; }
}

// 具体关联类（指定列名）
public class StudentEnrollment : StudentAssociation<Enrollment>
{
    [Column("EnrollmentId")]
    public override int AssociatedEntityId { get; set; }
}

public class StudentClub : StudentAssociation<Club>
{
    [Column("ClubId")]
    public override int AssociatedEntityId { get; set; }
}

注意事项 #

• EF Core中使用继承基类时，需确保特性或Fluent API正确映射列名，避免数据库字段名错误。
• 若DbContext已通过依赖注入管理，不要在方法内重复创建实例，直接注入使用即可。

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