{"id":4609,"date":"2019-06-29T20:27:54","date_gmt":"2019-06-30T01:27:54","guid":{"rendered":"http:\/\/neosmart.net\/blog\/?p=4609"},"modified":"2019-07-01T16:25:38","modified_gmt":"2019-07-01T21:25:38","slug":"sqlite-cache-for-asp-net-core","status":"publish","type":"post","link":"https:\/\/neosmart.net\/blog\/sqlite-cache-for-asp-net-core\/","title":{"rendered":"A persistent cache for ASP.NET Core"},"content":{"rendered":"

One of the nicest things about ASP.NET Core is the availability of certain singleton models that greatly simplify some very common developer needs. Given that (depending on who you ask) one of the two hardest problems in computing is caching1<\/a><\/sup>, it’s extremely helpful that ASP.NET Core ships with several models for caching data, chief of which are IMemoryCache<\/code> and IDistributedCache<\/code>, added to an ASP.NET Core application via dependency injection and then available to both the framework and the application itself. Although these two expose almost identical APIs, they differ rather significantly in semantics.2<\/a><\/sup><\/p>\n

<\/p>\n

As the name suggests, IMemoryCache<\/code> is an in-memory cache with ephemeral storage: its contents are lost when the application is restarted. As for IDistributedCache<\/code>, it’s a little confusing because the two are not actually counterparts: the opposite of an IMemoryCache<\/code> would be a hypothetical IPersistentCache<\/code>, whereas the primary motivation behind the existence of IDistributedCache<\/code> is not to add persistence to IMemoryCache<\/code> but rather turn it into an ostensibly shared cache accessible to multiple instances of an application sitting behind a load balancer (hopefully coherently so), and usually not on the same machine.<\/p>\n

As such, IDistributedCache<\/code> does not officially have a persistence model—however by virtue of its out-of-process implementation, it somewhat guarantees key-value caching resilient to application or worker process recycling. As a result, both application developers and Microsoft themselves have taken to using it for persistence-related reasons as well.3<\/a><\/sup> The problem is that the default implementations for IDistributedCache<\/code> are focused more on the “distributed” part rather than the “persistent” part, and a) don’t necessarily guarantee persistence, and b) aren’t necessarily intended to be used in non-distributed scenarios.<\/p>\n

For production purposes, setting up the backend service fulfilling IDistributedCache<\/code> (e.g. redis, NCache, or SQL Server) is generally easy enough for any competent sysadmin, but during development and testing developers may find themselves without any form of persistent caching, as the local IMemoryCache<\/code> is lost at application startup but there may be no viable IDistributedCache<\/code> offering readily available on the testing machine. Also keep in mind that unlike many alternatives, ASP.NET Core is a zero-dependency framework and doesn’t require background services, docker containers, etc. — not even a web server or IIS Express — and as a result many projects have no “configure a development environment” step apart from “open the solution file,” but to properly test components that rely on an IDistributedCache<\/code> implementation to provide persistence, a developer has hitherto needed to install and configure 3rd party dependencies.<\/p>\n

NeoSmart.Caching.Sqlite<\/code> is an open source project<\/a> available as a nuget package<\/a> for .NET Standard 2.0 and in particular for ASP.NET Core 2.2 implementing IDistributedCache<\/code> intended for single-machine deployment purposes (i.e. it is not actually a distributed cache but rather a persistent one), including both prototyping\/development and final production deployment. It leverages the in-process SQLite database to provide persistent-to-disk key-value caching, and (unlike the other IDistributedCache<\/code> offerings) requires no installation, no background services, external network servers, or admin privileges to configure and deploy during both testing or production.<\/p>\n

\/\/ using NeoSmart.Caching.Sqlite;\r\n\r\npublic void ConfigureServices(IServiceCollection services)\r\n{\r\n    ...\r\n\r\n    \/\/ Note: this *must* come before services.AddMvc()!\r\n    services.AddSqliteCache(options => {\r\n        options.CachePath = @\"C:\\data\\bazaar\\cache.db\";\r\n    });\r\n\r\n    services.AddMvc();\r\n\r\n    ...\r\n}\r\n<\/code><\/pre>\n
The closest option to a single-machine persistent cache available to developers\/sysadmins for .NET Core has probably been Microsoft SQL Express (via Microsoft.Caching.SqlServer<\/code> with a LocalDB<\/code> target configured in the connection string, but that has some considerable drawbacks:<\/p>\n