DEV Community

Mohammad Karimi
Mohammad Karimi

Posted on

25

How DbContext pooling works!

If you are developing a high-performance ASP.NET Core application using Entity Framework Core, you may want to consider using DbContext pooling to reduce the overhead of creating and disposing of DbContext instances. DbContext pooling is a feature that allows EF Core to reuse the same context instance across requests, instead of creating a new one every time. This can improve performance by avoiding the cost of setting up various internal services and objects that are necessary for DbContext to work.

In this blog post, I will explain how DbContext pooling works, how to enable it in your application, and what are some of the benefits and limitations of this feature.

How DbContext pooling works!

DbContext pooling works by reusing the same context instance across requests; this means that it’s effectively registered as a Singleton, and the same instance is reused across multiple requests (or DI scopes). However, unlike a normal Singleton, EF Core resets the state of the context before returning it to the pool, so that it behaves as if it was a new instance. This includes clearing any tracked entities, resetting any configuration options, and disposing of any internal resources.

To enable DbContext pooling, you must replace the AddDbContext method with AddDbContextPool in your ConfigureServices method. For example:

services.AddDbContextPool<BlogContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("BlogContext")));

You can also specify the maximum size of the pool by passing a second parameter to AddDbContextPool. The default size is 1024, which means that EF Core will keep up to 1024 context instances in the pool. If the pool size is exceeded, EF Core will return to creating new instances on demand.

DbContext Pooling

Benefits and limitations of DbContext pooling

The main benefit of DbContext pooling is that it can improve performance by reducing the overhead of creating and disposing of DbContext instances. This can be especially noticeable in scenarios where you have many concurrent requests that use DbContext for short-lived operations. According to Microsoft’s documentation, DbContext pooling can reduce request latency by up to 50% compared to non-pooling.

However, DbContext pooling also has some limitations that you need to be aware of. First of all, you need to make sure that your context does not hold any state that should not be shared across requests. For example, you should not use any static fields or properties in your context class, or store any data in the HttpContext.Items collection. You should also avoid using any custom services or objects that are not thread-safe or disposable in your context constructor or OnConfiguring method.

Another limitation is that DbContext pooling does not work well with some features of EF Core that rely on modifying the context state at runtime. For example, you cannot use ChangeTracker.QueryTrackingBehavior or ChangeTracker.AutoDetectChangesEnabled properties to change the tracking behavior of your context after it has been created. You also cannot use a Database.SetCommandTimeout or Database.SetConnectionString methods to change the database connection settings of your context after it has been created. If you need to use these features, you should either disable DbContext pooling or use a separate non-pooled context for those operations.

Finally, DbContext pooling may not have a significant impact on performance if your application does not use DbContext extensively, or if your database operations are long-running or complex. In these cases, the cost of creating and disposing of DbContext instances may be negligible compared to the cost of executing queries or saving changes. You should always measure the performance of your application before and after enabling DbContext pooling to see if it makes a difference for your scenario.

dotnet #entityframework #EF

Image of Timescale

🚀 pgai Vectorizer: SQLAlchemy and LiteLLM Make Vector Search Simple

We built pgai Vectorizer to simplify embedding management for AI applications—without needing a separate database or complex infrastructure. Since launch, developers have created over 3,000 vectorizers on Timescale Cloud, with many more self-hosted.

Read full post →

Top comments (1)

Collapse
 
vivekjvs profile image
Vivek Srivatsav Jandhyala

I have compiled queries defined as static readonly properties in dbcontext class, is it going to be a problem if I use dbcontext pooling. And also could you please elaborate on the point "you should not store any data in the HttpContext.Items collection". How is storing items in http context going to cause any problems.

Billboard image

The Next Generation Developer Platform

Coherence is the first Platform-as-a-Service you can control. Unlike "black-box" platforms that are opinionated about the infra you can deploy, Coherence is powered by CNC, the open-source IaC framework, which offers limitless customization.

Learn more