Understanding Related Data Loading in Entity Framework Core

Related data loading is an important aspect of working with Entity Framework Core. It allows you to retrieve and manipulate data from related entities using navigation properties. There are three common patterns for loading related data: eager, explicit, and lazy loading. In this post, we will explore each of these patterns in detail, along with their pros and cons.

Eager Loading

Eager loading is a pattern where the related data is loaded from the database as part of the initial query. This means that all the required data is loaded upfront and can be accessed without making additional database queries.

To use eager loading in Entity Framework Core, you can use the Include() method to specify which related entities to load. Here's an example:
using (var context = new BloggingContext())
    var blogs = context.Blogs
        .Include(blog => blog.Posts)
This code retrieves all the blogs from the database along with their related posts using eager loading.

The main advantage of eager loading is that it can improve performance by reducing the number of database queries required to retrieve related data. However, it can also result in the retrieval of more data than needed, leading to unnecessary overhead.

Explicit Loading

Explicit loading is a pattern that is used to load related data when it is needed, rather than loading it eagerly when the main query is executed. In Entity Framework Core, explicit loading is achieved by using the Load() method on a navigation property of an entity.

To illustrate how explicit loading works, consider the following example:
using (var context = new BloggingContext())
    var blog = context.Blogs
        .Single(b => b.BlogId == 1);

        .Collection(b => b.Posts)

        .Reference(b => b.Owner)
In this example, we retrieve a specific blog entity from the database and then use the Entry() method to obtain a reference to the entity's state in the context. We can then call the Collection() method on the entity's navigation property for posts and use the Load() method to explicitly load the related post entities.

Similarly, we can use the Reference() method to explicitly load the related entity for the blog owner.

Explicit loading can be useful when you have a large number of related entities, and you only need to load a subset of them based on specific criteria. By using explicit loading, you can avoid the overhead of loading all related entities, which can improve the performance of your application.

However, explicit loading can also result in additional roundtrips to the database if not used correctly. It is important to use explicit loading judiciously and only when it is necessary.

Lazy Loading

Lazy loading is a feature in Entity Framework Core that automatically loads related data from the database when it's accessed. This means that related data is only loaded when it's needed, which can improve performance and reduce unnecessary database calls.

To enable lazy loading in Entity Framework Core, you need to install the Microsoft.EntityFrameworkCore.Proxies package and configure your DbContext to use lazy loading proxies. This can be done in the OnConfiguring method of your DbContext as shown below:
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    => optionsBuilder
Alternatively, you can also use the UseLazyLoadingProxies method when configuring your DbContext:
    b => b.UseLazyLoadingProxies()
Once lazy loading is enabled, you can access related data as usual using navigation properties. The related data will be automatically loaded when the navigation property is accessed.

It's important to note that lazy loading can lead to performance issues if misused, as it can result in a large number of database calls. To avoid this, it's recommended to use eager or explicit loading in cases where you know that related data will be needed.

Choosing the Right Loading Strategy

The choice between eager, explicit, and lazy loading depends on various factors, such as performance, complexity, and data access patterns. Here are some guidelines for choosing the right loading strategy based on the specific use case:
  • Use eager loading when you know that you will need all or most of the related entities, and when the related data is not too complex.
  • Use explicit loading when you only need to load a specific subset of related entities, or when the related data is too complex to be retrieved with a single query.
  • Use lazy loading sparingly, and only when you are sure that the related entities will not cause performance issues, and when the related data is not too complex.


In conclusion, related data loading is an important feature of Entity Framework Core that allows you to retrieve related entities from the database. Eager loading, explicit loading, and lazy loading are the three main loading patterns in Entity Framework Core, each with its own advantages and disadvantages.

By experimenting with different loading strategies and following the guidelines outlined in this post, you can optimize the performance and maintainability of your Entity Framework Core applications.



Popular posts from this blog

How to Check if a String is a Palindrome in C#

Decoupling Components in C# Applications with MediatR