Lazy Loading and Eager Loading in Entity Framework

In Entity Framework (EF), Lazy Loading and Eager Loading are two approaches to loading related data from the database. Both methods serve specific purposes, and understanding when and how to use them is essential for optimizing data retrieval and application performance.

1. Lazy Loading

Lazy Loading is a technique where related data is loaded only when it is accessed for the first time. This means that the initial query does not retrieve the related entities, which are instead fetched automatically on-demand when you access the navigation property.

• Pros: Reduces initial data load, which can be beneficial when related data might not be needed.
• Cons: Can lead to multiple round trips to the database, especially in a loop, which might cause performance issues (known as the N+1 problem).

Enabling Lazy Loading

In EF Core, you enable lazy loading by installing the Microsoft.EntityFrameworkCore.Proxies package and using the .UseLazyLoadingProxies() method in your DbContext configuration.

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder
        .UseSqlServer("your_connection_string")
        .UseLazyLoadingProxies();
}

Then, ensure that the related entities are defined as virtual properties:

public class Order
{
    public int OrderId { get; set; }
    public DateTime OrderDate { get; set; }

    // Virtual navigation property to enable lazy loading
    public virtual Customer Customer { get; set; }
}

Example of Lazy Loading in Action

var order = context.Orders.FirstOrDefault(o => o.OrderId == 1);
// Customer data is only loaded when accessed
var customerName = order.Customer.Name;

In this example, order.Customer is loaded from the database only when you access it. If you don’t access the Customer property, EF won’t load the related data.

2. Eager Loading

Eager Loading is a technique where related data is loaded along with the main entity in a single query using the Include method. This method is preferable when you know that related data will be needed immediately, as it reduces the number of database calls.

• Pros: Reduces database round trips by loading all necessary data in a single query. Prevents the N+1 problem.
• Cons: Can lead to over-fetching if related data isn’t needed, potentially increasing memory usage.

Using Eager Loading with Include

Eager loading is achieved in Entity Framework by using the Include and ThenInclude methods to specify which related entities should be loaded.

var order = context.Orders
    .Include(o => o.Customer)
    .FirstOrDefault(o => o.OrderId == 1);

In this example, the Customer entity is loaded along with the Order, so when you access order.Customer, no additional query is made to the database.

Loading Nested Related Entities

You can also use ThenInclude to load nested related entities. This is useful when you need to load multiple levels of related data.

var orders = context.Orders
    .Include(o => o.Customer)
    .ThenInclude(c => c.Address)
    .ToList();

Here, the query loads Order, Customer, and Address in one go, avoiding multiple round trips.

3. Comparison Between Lazy Loading and Eager Loading

4. Choosing Between Lazy Loading and Eager Loading

• Use Eager Loading (Include/ThenInclude) when:
  • You know you’ll need related data immediately.
  • There is a risk of the N+1 problem due to looping over data with related entities.
  • You want to optimize query performance by reducing database calls.
• Use Lazy Loading when:
  • The related data may not always be needed.
  • You want to avoid loading large, complex related data upfront.
  • You’re working with simpler data structures where fetching related data as needed has minimal performance impact.

5. Explicit Loading

Explicit Loading is another technique where related data is loaded manually using the Load method, allowing for fine-grained control over when related data is retrieved. It’s useful when neither eager nor lazy loading fits the requirement.

var order = context.Orders.FirstOrDefault(o => o.OrderId == 1);
context.Entry(order).Reference(o => o.Customer).Load(); // Explicitly loads Customer

This approach allows you to load related data only if certain conditions are met, offering a flexible alternative to lazy and eager loading.