NeoSmart.Caching.Sqlite 7.0.0-preview1

Prefix Reserved
.NET 5.0 This package targets .NET 5.0. The package is compatible with this framework or higher. .NET Core 3.1 This package targets .NET Core 3.1. The package is compatible with this framework or higher. .NET Standard 2.0 This package targets .NET Standard 2.0. The package is compatible with this framework or higher.
This is a prerelease version of NeoSmart.Caching.Sqlite.
There is a newer version of this package available.
See the version list below for details. 
dotnet add package NeoSmart.Caching.Sqlite --version 7.0.0-preview1                

                    
                

            
NuGet\Install-Package NeoSmart.Caching.Sqlite -Version 7.0.0-preview1
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package. 
<PackageReference Include="NeoSmart.Caching.Sqlite" Version="7.0.0-preview1" />
For projects that support PackageReference, copy this XML node into the project file to reference the package. 
paket add NeoSmart.Caching.Sqlite --version 7.0.0-preview1                

                    
                

            
#r "nuget: NeoSmart.Caching.Sqlite, 7.0.0-preview1"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package. 
// Install NeoSmart.Caching.Sqlite as a Cake Addin
#addin nuget:?package=NeoSmart.Caching.Sqlite&version=7.0.0-preview1&prerelease

// Install NeoSmart.Caching.Sqlite as a Cake Tool
#tool nuget:?package=NeoSmart.Caching.Sqlite&version=7.0.0-preview1&prerelease

SqliteCache for ASP.NET Core

SqliteCache is a persistent cache implementing IDistributedCache for 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.

Why NeoSmart.Caching.Sqlite?

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.Sqlite has no dependencies on background services that hog system resources and need to be updated or maintained (cough cough NCache cough cough)
  • NeoSmart.Caching.Sqlite is fully cross-platform and runs the same on your Windows PC or your colleagues' Linux, FreeBSD, and macOS workstations (unlike, say, Redis)
  • NeoSmart.Caching.Sqlite doesn't need administrator privileges to install - or even any installation for that matter (SQL Express LocalDB, this one is aimed at you)
  • NeoSmart.Caching.Sqlite is a fully contained IDistributedCache offering 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.

Installation

SqliteCache is available via the NuGet, and can be installed in the Package Manager Console as follows:

Install-Package NeoSmart.Caching.Sqlite

Usage

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:

// using NeoSmart.Caching.Sqlite;

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();

    ...
}

License

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.

Contributing

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!

Product Compatible and additional computed target framework versions.
.NET net5.0 is compatible.  net5.0-windows was computed.  net6.0 is compatible.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 is compatible.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 was computed.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed. 
.NET Core netcoreapp2.0 was computed.  netcoreapp2.1 was computed.  netcoreapp2.2 was computed.  netcoreapp3.0 was computed.  netcoreapp3.1 is compatible. 
.NET Standard netstandard2.0 is compatible.  netstandard2.1 was computed. 
.NET Framework net461 was computed.  net462 was computed.  net463 was computed.  net47 was computed.  net471 was computed.  net472 was computed.  net48 was computed.  net481 was computed. 
MonoAndroid monoandroid was computed. 
MonoMac monomac was computed. 
MonoTouch monotouch was computed. 
Tizen tizen40 was computed.  tizen60 was computed. 
Xamarin.iOS xamarinios was computed. 
Xamarin.Mac xamarinmac was computed. 
Xamarin.TVOS xamarintvos was computed. 
Xamarin.WatchOS xamarinwatchos was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages (1)

Showing the top 1 NuGet packages that depend on NeoSmart.Caching.Sqlite:

Package Downloads
NeoSmart.Caching.Sqlite.AspNetCore

ASP.NET Core dependency-injection integrations for NeoSmart.Caching.Sqlite

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated
9.0.0-preview1 80 10/26/2024
8.0.0 32,693 3/2/2024
7.0.1 15,862 9/19/2023
7.0.0 1,909 9/5/2023 7.0.0 is deprecated.
7.0.0-preview1 703 6/29/2023
6.1.0 13,351 6/29/2023
6.1.0-preview1 13,502 1/30/2023
6.0.1 41,714 1/10/2022
6.0.0 1,644 1/10/2022 6.0.0 is deprecated.
5.0.2 3,248 1/10/2022
5.0.1 1,531 1/10/2022 5.0.1 is deprecated.
5.0.0 1,534 1/10/2022 5.0.0 is deprecated.
5.0.0-preview3 239 11/2/2021
5.0.0-preview2 291 7/31/2021
5.0.0-preview1 256 7/13/2021
3.1.1 43,210 1/18/2020
3.1.0 1,692 1/4/2020
0.1.1 4,883 6/21/2019
0.1.0 1,616 6/20/2019

Version 7.0:
- SqliteCache no longer depends on SQLitePCLRaw.bundle_green.

 ASP.NET users do not have to change anything, but other .NET Core users will need to install either
 SQLitePCLRaw.bundle_green and call `SQLitePCL.Batteries.Init()` before instantiating SqliteCache,
 or else install the correct SQLitePCLRaw.provider.xxx version that matches the target platform and call
 `SQLitePCL.raw.SetProvider(new SQLitePCL.SQLite3Provider_whatever())` before using SqliteCache.

Version 6.1:
- Add methods to clear the cache (SqliteCache.Clear() and SqliteCache.ClearAsync())
- SQLitePCLRaw upgraded to 2.1.4
- Compatible w/ SQLite builds compiled with SQLITE_DSQ=0

Version 6.0:
- Updates all Entity Framework and Microsoft Extension dependencies to v6.x

Version 5.0:
- WAL mode and normal synchronization pragmas are set at startup, dramatically improving performance
- ILogger constructor parameter is now optional
- A separate SqliteConnection is used for each SqlCommand instance, fixing threading issues under UWP
- Makes it possible to inject SqliteCache directly (rather than only as IDistributedCache)
- Adds IAsyncDisposable implementation for .NET Core 3.1 and above
- Adds a bulk insert option to insert many key-value pairs quickly (credit to first-time contributor Elias Baumgartner aka @Rap22tor)
- Fixes an issue w/ incorrect handling of user-specified non-UTC expiration dates (credit to first-time contributor Ravindu Liyanapathirana, aka @ravindUwU)

Version 3.1:
- Added .netcoreapp3.1 target
- Switched to SQLitePCLRaw.bundle_e_sqlite3 (same as .NET Core 3.1 web projects)
- SqliteCache is now a sealed class to prevent dispose problems if derived
- Version number aligns with .NET Core semantic versioning