https://github.com/SteffenMangold/EntityFrameworkCore.Cacheable
EntityFrameworkCore second level cache
https://github.com/SteffenMangold/EntityFrameworkCore.Cacheable
c-sharp cache database dotnet-core dotnet-framework dotnet-standard entity-framework orm
Last synced: 14 days ago
JSON representation
EntityFrameworkCore second level cache
- Host: GitHub
- URL: https://github.com/SteffenMangold/EntityFrameworkCore.Cacheable
- Owner: SteffenMangold
- License: apache-2.0
- Created: 2018-12-23T21:16:47.000Z (over 6 years ago)
- Default Branch: master
- Last Pushed: 2024-01-31T16:41:42.000Z (about 1 year ago)
- Last Synced: 2024-11-04T15:06:40.757Z (6 months ago)
- Topics: c-sharp, cache, database, dotnet-core, dotnet-framework, dotnet-standard, entity-framework, orm
- Language: C#
- Size: 247 KB
- Stars: 193
- Watchers: 13
- Forks: 27
- Open Issues: 13
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
EntityFrameworkCore.Cacheable
A high-performance second-level query cache for Entity Framework Core.
## What is EF Core Cacheable?
Entity Framework (EF) Core Cacheable is an extension library for the popular Entity Framework data access technology.
It provides caching functionality for all types of query results. Based on the expression tree and parameters, the context decides whether to execute the query against the database or return the result from memory.
## How caching affects performance
This is a sample result of 1,000 iterations of an uncached and cached query called against a well-performing MSSQL database.
```
Average database query duration [+00:00:00.1698972].
Average cache query duration [+00:00:00.0000650].
Cached queries are x2,611 times faster.
```
Even with an InMemory test database, the results are significantly faster.
```
Average database query duration [+00:00:00.0026076].
Average cache query duration [+00:00:00.0000411].
Cached queries are x63 times faster.
```
The performance gain can be even higher, depending on the database performance.
## Install via NuGet
You can view the [package page on NuGet](https://www.nuget.org/packages/EntityFrameworkCore.Cacheable/).
To install `EntityFrameworkCore.Cacheable`, run the following command in the Package Manager Console:
```
PM> Install-Package EntityFrameworkCore.Cacheable
```
This library also uses the [Data.HashFunction](https://github.com/brandondahler/Data.HashFunction/) and [aspnet.Extensions](https://github.com/aspnet/Extensions) as InMemory cache.
## Configuring a DbContext
There are three types of configurations for the DbContext to support `Cachable.`
Each sample only uses' UseSqlite' to show the pattern.
For more information about this, please read [configuring DbContextOptions](https://docs.microsoft.com/de-de/ef/core/miscellaneous/configuring-dbcontext#configuring-dbcontextoptions).
### Constructor argument
Application code to initialize from constructor argument:
```csharp
var optionsBuilder = new DbContextOptionsBuilder();
optionsBuilder
.UseSqlite("Data Source=blog.db")
.UseSecondLevelCache();
using (var context = new CacheableBloggingContext(optionsBuilder.Options))
{
// do stuff
}
```
### OnConfiguring
Context code with `OnConfiguring`:
```csharp
public partial class CacheableBloggingContext : DbContext
{
public DbSet Blogs { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
if (!optionsBuilder.IsConfigured)
{
optionsBuilder.UseSqlite("Data Source=blog.db");
optionsBuilder.UseSecondLevelCache();
}
}
}
```
### Using DbContext with dependency injection
Adding the Dbcontext to dependency injection:
```csharp
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext(options => options
.UseSqlite("Data Source=blog.db"))
.UseSecondLevelCache();
}
```
This requires [adding a constructor argument](https://docs.microsoft.com/de-de/ef/core/miscellaneous/configuring-dbcontext#using-dbcontext-with-dependency-injection) to your DbContext type that accepts DbContextOptions.
## Usage
To use result caching, you simply need to add `.Cacheable(...` to your query and define a TTL parameter.
```csharp
var cacheableQuery = cacheableContext.Books
.Include(d => d.Pages)
.ThenInclude(d => d.Lines)
.Where(d => d.ID == 200)
.Cacheable(TimeSpan.FromSeconds(60));
```
### Custom Cache Provider
Alternatively, you can provide a custom implementation of `ICacheProvider` (default is `MemoryCacheProvider`).
This provides an easy option for supporting other caching systems like [ redis](https://redis.io/) or [Memcached](https://memcached.org/).
```csharp
optionsBuilder.UseSecondLevelCache(new MyCachingProvider());
```
-----------------
## Contributors
The following contributors have either created (that only me:stuck_out_tongue_winking_eye:) the project, have contributed
code, are actively maintaining it (including documentation), or in other ways
being helpful contributors to this project.
| | Name | GitHub |
| :--------------------------------------------------------------------------------: | --------------------- | ------------------------------------------------------- |
| 
| Steffen Mangold | [@SteffenMangold](https://github.com/SteffenMangold) |
| 
| Smit Patel | [@smitpatel](https://github.com/smitpatel) |