Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

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: 2 months ago
JSON representation

EntityFrameworkCore second level cache

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 extention library for the popular Entity Framework data access technology.



It provides caching functionality for all types of query results. Based on expression tree and parameters, the context decide rather to execute query against database or returning result from memory.



## How caching affects performance



This a sample result of 1,000 iterations of an uncached and cached query, called agains a really good 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 a InMemory test database, the results are significant 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 configuring the DbContext to support `Cachable`.

Each sample use `UseSqlite` as option only for showing 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 get in use of 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 a easy option for supporting other caching systems like [![](https://redis.io/images/favicon.png) redis](https://redis.io/) or [Memcached](https://memcached.org/).



```csharp

optionsBuilder.UseSecondLevelCache(new MyCachingProvider());

```



-----------------



## Contributors



The following contributors have either created (thats only me :stuck_out_tongue_winking_eye:) the project, have contributed

code, are actively maintaining it (including documentation), or in other ways

being helpfull contributors to this project. 



|                                                                                    | Name                  | GitHub                                                  |

| :--------------------------------------------------------------------------------: | --------------------- | ------------------------------------------------------- |

|    | Steffen Mangold       | [@SteffenMangold](https://github.com/SteffenMangold)    |

|     | Smit Patel            | [@smitpatel](https://github.com/smitpatel)              |