Lazy Loading in EF Core
Lazy Loading was introduced in Entity Framework Core with EF Core 2.1 to allow better optimizations, performance, and working of the software.
- Lazy Loading is a method of loading and processing only the required data to run the application, the data which is not required at that moment stays untouched.
- It allows the system to perform better and faster and it has become an essential part of the Entity Framework core.
To enable Lazy Loading in Entity Framework core, there are 2 methods which can be applied.
The First method is by installing the Proxy Package provided by Microsoft. All the developer has to do is install
Microsoft.EntityFrameworkCore.Proxies
package which will add all the required proxies needed to run Lazy Loading.After installing the package, the system will ask the developer to allow the installed proxies to access the databases and enable lazy loading.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<EFCoreContext>(b => b.UseLazyLoadingProxies()
.UseSqlServer(ConnectionString));
}
public class Actor
{
public int ActorId { get; set; }
public string FullName { get; set; }
public virtual List<Movie> Movies{ get; set; }
}
public class Movie
{
public int MovieId { get; set; }
public string Title { get; set; }
public virtual Actor Actor{ get; set; }
}
The second method of enabling Lazy Loading in Entity Framework Core is using the
ILazyLoader
interface.- The
ILazyLoader
interface represents a component that is responsible for loading navigation properties if they haven't already been loaded. - It can be embedded directly into the principle entity of the database.
- The
ILazyLoader
can be found inMicrosoft.EntityFrameworkCore.Abstraction
Package.
public class Actor
{
private List<Movie> _movies;
public Actor()
{
}
private Actor(ILazyLoader lazyLoader)
{
LazyLoader = lazyLoader;
}
private ILazyLoader LazyLoader { get; set; }
public int ActorId { get; set; }
public string FullName { get; set; }
public List<Movie> Movies
{
get => LazyLoader.Load(this, ref _movies);
set => _movies = value;
}
}
public class Movie
{
private Actor _actor;
public Movie()
{
}
private Movie(ILazyLoader lazyLoader)
{
LazyLoader = lazyLoader;
}
private ILazyLoader LazyLoader { get; set; }
public int MovieId { get; set; }
public string Title { get; set; }
public Actor Actor
{
get => LazyLoader.Load(this, ref _actor);
set => _actor = value;
}
}
Lazy loading is helpful once the association between entities is a one-to-many relationship and you're certain that associated entities aren't going to be utilized immediately.
It helps in functionality reducing application startup time, less memory utilization, and reduce the load on DBMS due to a small amount of query load on the server.
What can be concluded from Lazy Loading is that this feature is useful in some scenarios, otherwise, it could distract the users and developers if they forget to disable the feature.
Last modified 2yr ago