同一列外键引用实体框架中的多个表

Question

I have two class

public class TypeA
{
    public Guid Id { get; set; }
    public List<Comment> Comments { get; set; }
}
public class TypeB
{
    public Guid Id { get; set; }
    public List<Comment> Comments { get; set; }
}

And then there is

public class Comment
{
    public Guid Id { get; set; }
    public Guid ParentId { get; set; } //foreign key either to TypeA or TypeB
    public int Type { get; set; } //shows which class is referenced by foreign key ParentId
}

Comment have foreign key either to TypeA or to TypeB . And there is property Type which tells which foreign key is being referenced .

Now I just do

_context.Set<TypeA>().Include(x => x.Comments).First(x => x.Id == Id)

But is it possible to limit Include statement or write a query which would check Type property for appropriate foreign key reference, something like

_context.Set<TypeA>().Include(x => x.Comments.Where(c=>c.Type == 1)).First(x => x.Id == Id)

I imagine it could be done while grouping Comment s in query, but TypeA and TypeB has number of properties and I would like to avoid writing new keyword in select statement to assign all properties.

EDIT:

I' pretty much happy with what I have now. I am doing this for sanity, just in case TypeA and TypeB id property would be the same (99.9999999 it won't).

Answer 1

You don't need to filter something in the Include statement if you have set up your entity mappings properly.

public class TypeA
{
    public Guid Id { get; set; } = Guid.NewGuid();
    public virtual ICollection<Comment> Comments { get; set; } = new List<Comment>();
    public Comment AddComment(string text)
    {
        var comment = new Comment { Id = Guid.NewGuid(), ParentId = Id, Type = Types.TypeA, Text = text };
        Comments.Add(comment);
        return comment;
    }
}

public class TypeB
{
    public Guid Id { get; set; } = Guid.NewGuid();
    public virtual ICollection<Comment> Comments { get; set; } = new List<Comment>();
    public Comment AddComment(string text)
    {
        var comment = new Comment { Id = Guid.NewGuid(), ParentId = Id, Type = Types.TypeB, Text = text };
        Comments.Add(comment);
        return comment;
    }
}

public enum Types
{
    TypeA = 0,
    TypeB = 1
}

public class Comment
{
    public Guid Id { get; set; }
    public Guid ParentId { get; set; }
    public Types Type { get; set; }
    public string Text { get; set; }
}

public class MyContext : DbContext
{
    public DbSet<TypeA> TypeAs { get; set; }
    public DbSet<TypeB> TypeBs { get; set; }

    public MyContext() : base("Name=MyContext") { }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

        modelBuilder.Entity<TypeA>()
            .HasKey(e => e.Id)
            .HasMany(e => e.Comments).WithMany();

        modelBuilder.Entity<TypeB>()
            .HasKey(e => e.Id)
            .HasMany(e => e.Comments).WithMany();
    }
}
internal sealed class Configuration : DbMigrationsConfiguration<MyContext>
{
    public Configuration()
    {
        AutomaticMigrationsEnabled = true;
    }
}

void Main()
{   
    // helper code to use migrations, just for demo purposes
    var migrator = new DbMigrator(new Configuration());
    migrator.Update();
    //

    var db = new MyContext();
    var a = new TypeA { Id = Guid.NewGuid() };
    db.TypeAs.Add(a);

    var b = new TypeB { Id = Guid.NewGuid() };
    db.TypeBs.Add(b);

    db.SaveChanges();

    a.AddComment("A1 ");
    a.AddComment("A2");

    b.AddComment("B1");
    b.AddComment("B2");
    b.AddComment("B3");

    db.SaveChanges();

    var dba = db.TypeAs.Include(x => x.Comments).First(e => e.Id == a.Id);
    foreach (var c in dba.Comments)
    {
        Console.WriteLine("{0} {1} {2} {3}", c.Text, c.Id, c.ParentId, c.Type.ToString());
    }
}

The only drawback is that there will be additional linking tables involved (TypeAComment, TypeBComment).