SqliteCache is a persistent cache
implementing IDistributedCache for .NET and ASP.NET Core projects.
SqliteCache uses a locally stored SQLite database file (taking advantage of SQLite's battle-tested
safe multi-threaded access features) to replicate persistent caching, allowing developers to mimic
the behavior of staging or production targets without all the overhead or hassle of a traditional
IDistributedCache implementation. You can read more about its design and inspiration in the
official release post on the NeoSmart
blog.
The currently available options for caching in ASP.NET Core projects are either all ephemeral
in-memory cache offerings (IMemoryCache and co.) -- aka non-persistent -- or else have a whole
slew of dependencies and requirements that require at the very least administrator privileges and
background services hogging up system resources and needing updates and maintenance to requiring
multiple machines and a persistent network configuration.
NeoSmart.Caching.Sqlitehas no dependencies on background services that hog system resources and need to be updated or maintained (cough cough NCache cough cough)NeoSmart.Caching.Sqliteis fully cross-platform and runs the same on your Windows PC or your colleagues' Linux, FreeBSD, and macOS workstations (unlike, say, Redis)NeoSmart.Caching.Sqlitedoesn't need administrator privileges to install - or even any installation for that matter (SQL Express LocalDB, this one is aimed at you)NeoSmart.Caching.Sqliteis a fully containedIDistributedCacheoffering that is installed and updated alongside the rest of your packages via NuGet, Paket, or whatever other option you're already using to manage your dependencies.
SqliteCache is available via the NuGet, and can be installed in the Package Manager Console as follows:
Install-Package NeoSmart.Caching.Sqlite
If using this in an ASP.NET Core project, you can install NeoSmart.Caching.Sqlite.AspNetCore (also
or instead) to get a convenient helper method for dependency injection (used below):
Install-Package NeoSmart.Caching.Sqlite.AspNetCore
If you install NeoSmart.Caching.Sqlite.AspNetCore you do not need to manually install
NeoSmart.Caching.Sqlite as it it will be installed automatically/transitively.
Using SqliteCache is straight-forward, and should be extremely familiar for anyone that's configured
an ASP.NET Core application before. Starting by adding a namespace import using NeoSmart.Caching.Sqlite makes things easier as the editor will pull in the correct extension
methods.
If using SqliteCache in an ASP.NET Core project, the SQLite-backed cache should be added as an
IDistributedCache type by adding the following to your ConfigureServices method, by default
located in Startup.cs, after using the correct namespace NeoSmart.Caching.Sqlite.AspNetCore:
// using NeoSmart.Caching.Sqlite.AspNetCore;
public void ConfigureServices(IServiceCollection services)
{
...
// Note: this *must* come before services.AddMvc()!
services.AddSqliteCache(options => {
options.CachePath = @"C:\data\bazaar\cache.db";
});
services.AddMvc();
...
}Afterwards, the SqliteCache instance will be made available to both the framework and the
application via dependency injection, and can be imported and used via either the
IDistributedCache abstract type or the concrete SqliteCache type:
// using Microsoft.Extensions.Caching.Distributed;
public class FooModel(DbContext db, IDistributedCache cache)
{
_db = db;
_cache = cache;
cache.SetString("foo", "bar");
Assert.AreEqual(cache.GetString("foo"), "bar");
Assert.AreEqual(typeof(NeoSmart.Caching.Sqlite.SqliteCache),
cache.GetType());
}To take advantage of SqliteCache-specific features or functionality that aren't exposed via the
IDistributedCache façade, you'll need to inject SqliteCache into your classes/methods rather than
IDistributedCache. For example, to globally clear the cache after performing some operation:
// using NeoSmart.Caching.Sqlite;
public class BarModel(DbContext db, SqliteCache cache)
{
_db = db;
_cache = cache;
}
public ActionResult OnPostAsync()
{
...
await _db.SomethingDestructiveAsync();
// We need to invalidate all the cache, since it's too hard to
// account for the changes this operation caused for legacy reasons.
await _cache.ClearAsync();
...
}SqliteCache is developed and maintained by Mahmoud Al-Qudsi of NeoSmart Technologies. The project is provided free to the community under the terms of the MIT open source license.
We are open to pull requests and contributions aimed at the code, documentation, unit tests, or anything else. If you're mulling an extensive contribution, file an issue first to make sure we're all on the same page, otherwise, PR away!
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent