How does lazy loading work in entity framework

Whether you have used proxies or the ILazyLoader interface, lazy loading is now enabled in your application, and will take place as soon as you reference dependent entities in a relationship:.

If you add logging, you can see the SQL commands that are executed against the database each one highlighted in yellow :. The first query retrieves the authors, and then there are n more queries, where n represents the number of results from the first query.

Flooding the database with unnecessary queries can cause performance problems. The same result set can be obtained with two queries using Include :. The advice is not to use lazy loading unless you are certain that it is the better solution. This is why unlike in previous versions of EF lazy loading is not enabled by default in Entity Framework Core. EF Core Newsletter.

Bulk Delete. Bulk Update. Bulk Merge. Lazy Loading Related Data In Entity Framework Core Lazy loading of data is a pattern whereby the retrieval of data from the database is deferred until it is actually needed. Enabling lazy loading by proxies requires three steps: Install the Microsoft. In EF Core, you may load similar entities at multiple levels by combining the Include and ThenInclude extension methods. You can load related entities in Entity Framework Core in one of the following ways:.

You can also use LINQ method syntax to implement eager loading as well. The following code snippet shows how you can load related entities using Eager Loading in Entity Framework Core.

You can take advantage of the ThenInclude method to load multiple levels of related entities as well. Here's an example:. ToList ;. It is also possible to chain multiple calls to the ThenInclude extension method to load data in multiple levels. The following code snippet shows how multiple calls to the ThenInclude extension method can be chained.

Lazy loading is a pattern that enables you to defer the loading of data till the time it is actually needed. While this might give you benefits in certain use cases, it can also degrade the application's performance in certain other use cases such as web applications.

It should be noted that Entity Framework Core does not support Lazy Loading out of the box - you need to enable it explicitly. Lazy loading can be enabled using one of the following ways:. Install the Microsoft. Proxies package onto your project using the NuGet Package Manager. Next, you can take advantage of the UseLazyLoadingProxies method to facilitate the creation of proxies in the OnConfiguring method of your DbContext as shown in the following code snippet:.

Lastly, you should ensure that the navigation properties are marked as virtual. That's all you need to do! You can leverage the ILazyLoader interface to lazy load the navigation properties. To be able to use this approach, you should install the Microsoft.

Abstractions package onto your project. Next, you should reference the Microsoft. Infrastructure assembly in your program to be able to use the ILazyLoader interface. Your entity class should have two constructors - one that accepts a reference to the ILazyLoader interface as a parameter and the other is a default constructor. The following code snippet illustrates how lazy loading can be implemented using the ILazyLoader interface.

You can turn off lazy loading at the db context level by setting the LazyLoadingEnabled property to false as shown in the code snippet below:. This can be achieved, using the Include method, which returs the related entities as a part of the query and a large amount of data is loaded at once. For example, you have a User table and a UserDetails table related entity to User table , then you will write the code given below.

Here, we are loading the user with the Id equal to userId along with the user details. If you have multiple level of child entities, then you can load, using the query given below. Lazy Loading It is the default behavior of an Entity Framework, where a child entity is loaded only when it is accessed for the first time. It simply delays the loading of the related data, until you ask for it. For example, when we run the query given below, UserDetails table will not be loaded along with the User table.