软删除 EF Core 中的中间表行

Question

I have a need to use a soft delete of a relationship in a many to Many Relationship.

public class EntityA
{
   public int Id {get; set;}
   public ICollection<EntityB> BCollection {get; set;}
   public bool IsDeleted {get; set;}
}

public class EntityB
{
   public int Id {get; set;}
   public ICollection<EntityA> ACollection {get; set;}
   public bool IsDeleted {get; set;}
}

I can configure an intermediate table for the many to many relationship using the fluent API.

modelBuilder.Entity<EntityA>()
            .HasMany<EntityB>(s => s.BCollection)
            .WithMany(c => c.ACollection)
            .Map(cs =>
                    {
                        cs.MapLeftKey("AId");
                        cs.MapRightKey("BId");
                        cs.ToTable("ABRelationships");
                    });

All the entities in my database use an 'IsDeleted' flag to use soft deletion and I am making use of a global query filter to stop these entities from being returned on a normal query.

        modelBuilder.Entity<EntityA>().HasQueryFilter(x => x.IsDeleted);
        modelBuilder.Entity<EntityB>().HasQueryFilter(x => x.IsDeleted);

How would i add a query filter around the intermediate table so that instead of deleting the row from the intermediate table an IsDeleted flag is set and it is not automatically joined when looking at my relationships?

Answer 1

The comment by Svyatoslav lead me to the correct answer which is to make use of a third entity and create a using entity.

First I added a new entity class for the ABRelationship

public class ABEntity
{
    public int Id { get; set; }

    public bool IsDeleted { get; set; }

    [Required]
    [ForeignKey(nameof(EntityA))]
    public int EntityAId { get; set; }

    public EntityA EntityA { get; set; }

    [Required]
    [ForeignKey(nameof(EntityB))]
    public int EntityBId { get; set; }

    public EntityA EntityA { get; set; }

}

Then I added the new collection properties. I set them to be ignored from serialization with filters so the relationship entities where not mapped to responses.

public class EntityA
{
   public int Id {get; set;}
   public ICollection<EntityB> BCollection {get; set;}
   public bool IsDeleted {get; set;}

   [JsonIgnore]
   [IgnoreDataMember]
   public virtual ICollection<EntityAB> EntityAB{ get; set; }
}

public class EntityB
{
   public int Id {get; set;}
   public ICollection<EntityA> ACollection {get; set;}
   public bool IsDeleted {get; set;}

   [JsonIgnore]
   [IgnoreDataMember]
   public virtual ICollection<EntityAB> EntityAB{ get; set; }
}

I then used the 'UsingEntity' extension to map my relationship entity.

            modelBuilder.Entity<EntityA>()
            .HasMany(p => p.BCollection)
            .WithMany(p => p.ACollection)
            .UsingEntity<ABRelationshipEntity>(
                j => j
                    .HasOne(pt => pt.EntityA)
                    .WithMany(t => t.EntityAB)
                    .HasForeignKey(pt => pt.EntityAId),
                j => j
                    .HasOne(pt => pt.EntityB)
                    .WithMany(p => p.EntityAB)
                    .HasForeignKey(pt => pt.EntityBID));

Once I set the above the following global filter works to correctly filter out soft deleted relationships.

modelBuilder.Entity<ABRelationshipEntity>().HasQueryFilter(x => x.IsDeleted);