如何在实体框架 LINQ 中显式不加载嵌套类？

Question

This is an ASP Core 3.1 project using Entity Framework. I tried to find an answer but Google kept pointing me to the [NotMapped] attribute which is not related to my question.

I have 3 classes: Document, Paragraph, and Sentences A Document has many paragraphs, a paragraph has many sentences.

public class Document {
   public List<Paragraphs> paras {get;set;}
}
public class Paragraph{
   public int ParagraphId {get;set; }
   public List<Sentences> sents {get;set;}
}
public class Sentence{
   public string sent {get;set;}
}

When I pull documents from SQL using EF Core, I would like to get all documents and their respective paragraphs, but I do NOT want to include each paragraphs sentences. So if I looked at a Paragraph after pulling it from SQL, its Sentence List should be empty (the reason for this is I am trying to avoid overhead from all these sentences for this particular situation).

_context.Documents.Include(x=> x.Paragraphs).ToList();

Is there some kind of method that I could attach to Paragraphs within the Include lambda to not include the Sentences?

Answer 1

It's hard to tell for sure without seeing how you configured your Db Context, but the most likely reason why that's happening is, as @GertArnold pointed in the comments, that you configured the Sentences as a Collection of owned types .

So you might have something similar to the following:

modelBuilder.Entity<Paragraph>().OwnsMany(p => p.Sentences, s =>
{
    s.WithOwner().HasForeignKey("ParagraphId");
    ...
});

If you have configured your entities that way, then the Sentences will always be included when querying the Paragraphs by default.

From the documentation :

When querying the owner the owned types will be included by default. It is not necessary to use the Include method

To achieve the desired behaviour, you should instead configure your entities as a normal 1-N relationship:

modelBuilder.Entity<Paragraph>()
        .HasMany(p => p.Sentence)
        .WithOne();

PD: you should name your entities in singular instead of plural. I see that you have mixed up the names (ie Paragraphs =/= Paragraph).

Answer 2

In entity framework always use Select to select the properties that you plan to use. Only use Include if you plan to update the fetched values.

Certainly don't use it to safe you some typing!

The reason is that Include will fetch all columns of the table. Many of them you probably won't use.

Suppose you have a database with Schools and Students , with a standard many-to-many relation between Schools and Students: every School has zero or more Students; every Student attends exactly one School, namely the School that the foreign key refers to.

Every Student of School [10] will have a foreign key SchoolId with a value equal to 10. So if use Include to fetch School [10] with its 2000 Students , you will be transferring this value 10 over 2000 times, while you already know the value.

ICollection vs List

In entity framework relations between tables are described as virtual properties. If you follow the entity framework code first conventions , you'll see that the one-to-many relations are designed as virtual ICollection<...>

You decided to use List<Paragraph> . Are you sure that document.Paras[4] is the fourth paragraph? Even if you inserted paragraph [2] after you created paragraph [4]?

Furthermore: you use a List<...> , not an IList<...> , thus forcing entity framework to copy it's fetched data to a List, while internally it might have had a much smarter solution to fetch the collections.

Consider to stick to the Conventions and use virtual ICollection<...> , instead of `List<...>.

Use the Virtual ICollections

Requirement : I would like to get all documents and their respective paragraphs, but I do NOT want to include each paragraphs sentences.

var documentsWithTheirParagraphs = dbContext.Documents.Select(document => new
{
    // Select only the document properties that you plan to use:
    Id = document.Id,
    Title = document.Title,
    ...

    Paragraphs = documents.Paragraphs.Select(paragraph => new
    {
         // again: only the properties that you plan to use!
         Id = paragraph.Id,
         Title = paragraph.Title,
         ...

         // foreign key not needed, you already know the value
         // DocumentId = paragraph.DocumentId,

         // not wanted in your requirement, added to show how easy it is
         // if you use the virtual ICollections
         Sentences = paragraph.Sentences.Select(sentence => new
         {
             Id = sentence.Id,
             Text = sentence.Text,
             ...
         })
         .ToList(),
    })
    .ToList(),
});

Using the virtual ICollection<...> is a very intuitive method. Entity framework knows the relations between the tables, and creates the proper (Group)Join.

Do the GroupJoin yourself

Some people mention that the virtual ICollections can't be used when using EF-core. If you have an entity framework version that doesn't support this, you'll have to do the GroupJoin yourself. If there are not too many tables involved, the GroupJoin is not too complicated:

var documentsWithTheirParagraphs = dbContext.Documents.GroupJoin(
    dbContext.Paragraphs,

    document => document.Id,              // from each Document take the primary key
    paragraph => paragraph.DocumentId,    // from each Paragraph take the foreign key

    (document, paragraphsOfThisDocument) => new   // when they match, make one new:
    {
        Id = document.Id,
        Title = document.Title,
        ...

        Paragraphs = paragraphsOfThisDocument.Select(paragraph => new
        {
             Id = paragraph.Id,
             Title = paragraph.Title,
             ...
         })
         .ToList(),
    });

Answer 3

Entity Framework will fetch all nested classes from the database IF the Lazy Loading option is enabled and WHEN the nested classes are first requested - ie when the code execution reaches a point where it says paragraph.sents . If you never request the sentences in your code, they will never be fetched from the database.

But to get your head clear you can disable Lazy Loading and then only the nested classes that you include in your queries (with the include method) will be fetched.

Please note that Lazy Loading is disabled by default in .net core, so you must have enabled it somewhere (your startup class or context class).