在导航属性实体框架上正确使用接口

Question

I am developing an application which can connect to multiple similar databases using entity framework and Devart. I have done this by creating some interfaces which my EF models implement and it works ok, however I have come across a performance issue,

Take the following Interfaces

public interface IEventBookEntry {

     int EntryId { get;set;}

     int EventBookId {get;set;}

     bool Flagged {get;set;

     IEntry Entry {get;set;}

}

and

public Interface IEntry {

    int EntryId {get;set;}

    DateTime EntryTimestamp {get;set;}

    ICollection<IEventBookEntry> EventBookEntries {get;set;}

}

My two entity models (which connect to different databases) implement the above interfaces.

This means that i can write queries in my BLL layer which can run against either entity model, great stuff!

Let's take the following Linq method query:

   var eventBookEntries = new EventBookRepository().GetList(eb => eb.EventBookId == 123 && eb.Entry.EntryTimestamp > DateTime.Now.AddDays(-3));

The above code gets all the eventbook entries where eventBookId == 123 and the timestamp of the entry is within the past 3 days.

for completeness, here is the detail of the "GetList" method in the eventBookRepository

public IList<IEventBookEntry> GetList(Func<IEventBookEntry, bool> where, params Expression<Func<IEventBookEntry, object>>[] navigationProperties)
        {
            return new EventBookEntities().EventBookEntries.Where(where).ToList();
        }

You would expect the sql generated behind the scenes for this to be something like this

 SELECT Extent1.EntryId, Extent1.EventBookId, Extent1.Flagged 
  FROM EventBookEntries Extent1
  INNER JOIN Entries Extent2 ON Extent1.EntryId = Extent2.EntryId
  WHERE Extent1.EventBookId = 123
  AND Extent2.EntryTimestamp > 22/01/2016

Unfortunately, what happens is that we do not get a single query with a join to entries, what happens instead is that we get one query which retrieves all EventBookEntries where EventBookId = 123 then a query per row returned which gets each entry.

SELECT Extent1.EntryId, Extent1.EventBookId, Extent1.Flagged 
FROM EventBookEntries Extent1
WHERE Extent1.EventBookId = 123


SELECT Extent1.EntryId, Extent1.EntryTimestamp
FROM Entries Extent1
WHERE Extent1.EntryId = :EntityKeyValue1

So it looks like there's a problem when generating queries using navigation properties based on interface types,

Update

I have now changed to Code First Entity Framework with one model to remove all the smoke and mirrors. unfortunately I get exactly the same behavior.

Here's my model

    [Table("ENTRIES")]
    public class Entry
    {
        public Entry()
        {
           EventbookEntries = new List<EventbookEntry>();
        }

        [Key, Column("ENTRY_ID", Order = 1)]
        public long EntryId { get; set; }

        [Column("ENTRY_TIMESTAMP")]
        public DateTime EntryTimestamp { get; set; }


        [ForeignKey("EntryId")]
        public virtual ICollection<EventbookEntry> EventbookEntries {get;set;}

    }

and

    [Table("EVENT_BOOK_ENTRIES")]
    public class EventbookEntry
    {

        [Key, Column("ENTRY_ID", Order = 1)]
        public long EntryId { get; set; }

        [Key, Column("EVENT_BOOK_ID", Order = 2)]
        public long EventbookId { get; set; }

        [ForeignKey("EntryId")]
        public virtual Entry Entry { get; set; }
    }

I've also created a Db

So now I just use the dbContext directly and change my database provider which works a treat, however I still get the same behaviour!

My DbContext has 2 DbSets

 /// <summary>
 /// Gets or sets the entries.
 /// </summary>
 /// <value>The entries.</value>
 public DbSet<Entry> Entries { get; set; }

/// <summary>
/// Gets or sets the eventbook entries.
/// </summary>
/// <value>The eventbook entries.</value>
public DbSet<EventbookEntry> EventbookEntries { get; set; }

Here's my linq method query

var start = DateTime.Now.AddDays(-20);
var eventBookId = 124;

var eventbookEntries = new EventBookContext().EventbookEntries.Where(eb=> eb.EventbookId == eventBookId && eb.Entry.EntryTimestamp > start).ToList();

My Question is how do you implement interfaces on navigation properties in such a way as to ensure entity framework will use inner joins in queries rather than the behavior exhibited above?

Thanks

Wayward

Answer 1

You can use relationship using Fluent API ( http://www.entityframeworktutorial.net/code-first/configure-one-to-many-relationship-in-code-first.aspx )

in your DbContext :

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
        //one-to-many 
        modelBuilder.Entity<Entry>()
                    .HasRequired<EventbookEntry>(ev=> ev.EntryId ) 
                    .WithMany(ent => ent.EventbookEntries);     
}