Configure DBContext in Entity framework ASP.NET Core – Best Practices

In this post, we will see how to configure DbContext in Entity framework EFCore in ASP.NET Core.

We will see high-level guidelines and best practices that can be considered in general for configuring the DBCOntext.

As we looked into our article on Repository implementation for Entity framework DbContext instance represents the Unit Of Work and Repository patterns that can be used to query from a database and perform CRUD operations.

We shall be covering the below aspects in today’s article,

Configuring DbContext in Entity Framework is important for establishing the connection and performing efficient CRUD operations on the datastore of your choice.

Configuring the Default Database provider

This shall be the first thing we will do while configuring the DBContext instance.

It should have DbContextOptions which actually help set up required DBContext details along with the database provider to use and connection string etc.

Please do the below configuration to set the DBContext option.

Use AdDbContext() method to inject the required DBContext injected in the Service IoC container as below,

Using DBContext class to use Constructor Injections for the DbContextOptions<TContext> object as below,

 public EmployeeContext(DbContextOptions<EmployeeContext> options)
            : base(options)
        {
        }

        public virtual DbSet<Employee> Employee { get; set; }



..
.

Similarly, If using the override OnConfiguring method then you can achieve the same by DBContextOptionsbuilder to initialize the DbContextOption as below,

Lifetime management of DBContext

Using DbContext with Dependency Injection,

• Using DbContext via a dependency injection container is recommended.

• This ensures DbContext is created as per request by the API pipeline and disposed of based on lifetime management used while registering it.

• Add the DbContext type to the service container by using the AddDbContext method with Scoped lifetime (Recommended ).

• Using AddDbContext(..) ensures that you are registering the DBCOntext as a scoped object. i.e every new request will use the services injected and hence the new DBContext.

 public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.AddDbContext<EmployeeContext>(options =>
            {
                options.UseSqlServer(Configuration.GetConnectionString("EmployeeDB"));
            });
        }

Using DbContext without Dependency Injection,

If not using DI due to some reason, It becomes the implementor’s responsibility to keep track of such resources and dispose of them manually instead of the compiler doing it for you (as we see above using DI).

If not using DI – then It’s recommended to use the “Using” statement for creating the resources and disposing of them after their usage.

 using (var context = new EmployeeContext())
            {
                empList = _employeeContext.Employee.AsEnumerable().Select(x => x.EmployeeId).ToList();
            }

Access DBContext in Repository or other Services

It’s better to keep the same lifetime instance for Repository/Other Custom services and DBContext to avoid any issue related to Data corruption.

Define Connection Resiliency for your DBContext

The connection resiliency feature retries defaulted database commands automatically.

Use connection resiliency as it just takes a few lines of code for making your connection resilient.

For more details: Database Connection Resiliency in Entity Framework ASP.NET Core

If dealing with multiple DBContext, then Connection resiliency needs to be defined per DBContext separately.

Concurrency of EFCore DBContext

DBContext object is not thread-safe.

Using AddDbContext(..) however, ensures that you are registering the DBContext as Scoped. i.e every new request will use the new service instance and hence the new DBContext.

So ideally concurrency is implemented per request basic avoiding any data corruption issues.

However, It should be protected from any parallel access within the same request context.

It’s the implementor’s responsibility to implement the concurrency while using it in Task/Multithreaded operations.

As good practice also please make sure to use Synchronous and Asynchronous operation properly in the code.

In the above code, I marked method a method call with await as it invokes an Asynchronous operation. For more details please refer Understanding Async vs Sync programming

Client-Server query evaluation

.NET Core 3.0 onwards Entity Framework Core has blocked client-side query evaluation and recommends query execution on the server only.

If using the older version(<3.0) of EF Core please let the developer know about query evaluation support. One can configure the below warning for the same,

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            if (optionsBuilder.IsConfigured)
            {
                optionsBuilder.UseSqlServer(sqlConnectionString,
                 builder => builder.EnableRetryOnFailure())
                 .ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning));

            }

Or the same can be configured within Configure method in the StartUp.cs

Other references :

• Connection Resiliency Using EnableRetry and Execution Strategy- PartI

• Getting Started with EFCore in ASP.NET Core

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Summary

Today in this article we looked at guidelines around configuring the DBContext in Entity framework ASP.NET Core applications. We looked at various aspects like managing database providers, lifetime management, resiliency, and concurrency management while configuring the DBContext.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published(2024) best practices and guidelines for software design and development.