{"id":388891,"date":"2023-09-21T14:39:17","date_gmt":"2023-09-21T13:39:17","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=dotnet&p=388891"},"modified":"2023-09-21T14:39:21","modified_gmt":"2023-09-21T13:39:21","slug":"eager-lazy-and-explicit-loading-with-entity-framework-core","status":"publish","type":"dotnet","link":"https:\/\/blog.jetbrains.com\/en\/dotnet\/2023\/09\/21\/eager-lazy-and-explicit-loading-with-entity-framework-core","title":{"rendered":"Eager, Lazy and Explicit Loading with Entity Framework Core"},"content":{"rendered":"\n

Entity Framework Core (EF Core) supports a number of ways to load related data. There\u2019s eager loading, lazy loading, and explicit loading. Each of these approaches have their own advantages and drawbacks. In this post, let\u2019s have a quick look at each of these ways to load data for navigational properties!<\/p>\n\n\n\n

Eager loading<\/h2>\n\n\n\n

Eager loading is when you query one type of entity and immediately load related entities as part of it. For example, loading an Invoice<\/code> and immediately bringing in a collection of InvoiceLine<\/code>:<\/p>\n\n\n\n

var invoices = db.Invoices\n    .Include(invoice => invoice.InvoiceLines)\n    .ToList();\n\n\/\/ All invoices are already loaded...\nforeach (var invoice in invoices)\n{\n    \/\/ ...including all their Invoice lines\n    foreach (var invoiceLine in invoice.InvoiceLines)\n    {\n        \/\/ ...\n    }\n}<\/pre>\n\n\n\n
It\u2019s even possible to include navigational properties of InvoiceLine<\/code>, for example including the referenced Product<\/code>:<\/p>\n\n\n\n
var invoices = db.Invoices\n    .Include(invoice => invoice.InvoiceLines)\n    .ThenInclude(invoiceLine => invoiceLine.Product)\n    .ToList();\n\n\/\/ All invoices are already loaded...\nforeach (var invoice in invoices)\n{\n    \/\/ ...including all their invoice lines...\n    foreach (var invoiceLine in invoice.InvoiceLines)\n    {\n        \/\/ ...and related product!\n        var product = invoiceLine.Product;\n\n        \/\/ ...\n    }\n}<\/pre>\n\n\n\n
With eager loading, you can look at the .Include()<\/code> (and .ThenInclude()<\/code>) calls to see which navigational properties will be loaded from the database as part of the query. As a developer, I like how clearly this communicates what\u2019s going on in code.<\/p>\n\n\n\n
Eager loading does come with one issue: you have to remember to call .Include()<\/code> to query related entities. If you forget to do this, your code will keep working, except for the fact that in our example no invoice lines may be loaded at all, or only a partial set is returned if some invoice lines were loaded before. As a result, your code will not be reliable.<\/p>\n\n\n\n
ReSharper<\/a> and JetBrains Rider<\/a> both have inspections to help you out in such cases. When accessing any navigational property that has not been loaded, the IDE will tell you that the Usage of navigational property can return incomplete data<\/strong>.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
As usual, there\u2019s a quick-fix available through the Alt+Enter<\/kbd> menu where the IDE can update the query for you.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
ReSharper and JetBrains Rider then automatically add the necessary .Include()<\/code> calls for navigational properties, including those for navigational properties of navigational properties.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Lazy loading<\/h2>\n\n\n\n
With lazy loading, navigational properties are queried automatically when needed. This way, you don\u2019t have to remember to add all of those .Include()<\/code> calls like with eager loading! Additionally, only the data you are actually working with is queried from the database.<\/p>\n\n\n\n
var invoices = db.Invoices\n    .ToList();\n\n\/\/ All invoices are already loaded...\nforeach (var invoice in invoices)\n{\n    \/\/ ...invoice lines are queried when accessed...\n    foreach (var invoiceLine in invoice.InvoiceLines)\n    {\n        \/\/ ...the related product is also queried when accessed\n        var product = invoiceLine.Product;\n\n        \/\/ ...\n    }\n}<\/pre>\n\n\n\n
Lazy loading does come at a cost: there\u2019s a big risk that for each Invoice<\/code> entity you process (N<\/strong>), another query is run on the database to fetch the collection of InvoiceLine<\/code> for that entity (+1<\/strong>). As a result, the database may have to process N+1 queries instead of just one query in the eager loading example we saw earlier.<\/p>\n\n\n\n
The N+1 problem becomes very visible when using a (database) profiler. Tools like Dynamic Program Analysis can highlight the number of queries executed<\/a>. With lazy loading, you\u2019ll see many more queries being executed than you may have expected.<\/p>\n\n\n\n
If you do decide to use lazy loading in your application, a similar inspection is available in ReSharper and JetBrains Rider: Possible multiple queries to the database (N+1 problem)<\/strong>.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Alt+Enter<\/kbd> provides a quick-fix that switches to eager loading for this particular query, again adding .Include()<\/code> for navigational properties that are accessed.<\/p>\n\n\n\n
Explicit loading<\/h2>\n\n\n\n
Explicit loading is somewhat similar to lazy loading, in that data from navigational properties is only queried from the database when it\u2019s needed. The difference with lazy loading is that you\u2019ll have to query the related data explicitly. If you don\u2019t, only a partial or empty collection of invoice lines will be available, which would make your code unreliable.<\/p>\n\n\n\n
Therefore, you\u2019ll have to load the navigational data explicitly by asking the database context:<\/p>\n\n\n\n
var invoices = db.Invoices\n    .ToList();\n\n\/\/ All invoices are already loaded...\nforeach (var invoice in invoices)\n{\n    \/\/ ...but you'll have to explicitly load invoice lines when they are needed\n    db.Entry(invoice).Collection(p => p.InvoiceLines).Load();\n\n    foreach (var invoiceLine in invoice.InvoiceLines)\n    {\n        \/\/ ...\n    }\n}<\/pre>\n\n\n\n
With explicit loading, it becomes very clear where navigational data is queried in code. However, the N+1 issue is also present here, as each time an invoice is processed its invoice lines are queried separately.<\/p>\n\n\n\n
Summary<\/h2>\n\n\n\n
In this post, we have seen different mechanisms for loading related data with Entity Framework Core:<\/p>\n\n\n\n