DEV Community

Mohammad Karimi
Mohammad Karimi

Posted on

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 =>

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

Top comments (0)