ASP.NET Core's IDistributedCache interface provides a powerful abstraction for distributed caching, but it ships with limited built-in providers. This guide shows you how to build a custom IDistributedCache implementation backed by MariaDB/MySQL using Dapper for lightweight data access.
This is particularly useful when you want to share cached data across multiple application instances without adding a dedicated caching service like Redis.
Why Use MariaDB for Distributed Caching?
Using MariaDB as a cache store makes sense when your infrastructure already runs MariaDB and you want to minimize operational complexity. Benefits include: shared cache across multiple app servers, persistence across restarts, and no additional infrastructure required.
Database Schema
First, create the cache table in your MariaDB/MySQL database:
CREATE TABLE Cache (
CacheKey VARCHAR(255) NOT NULL PRIMARY KEY,
CacheValue LONGBLOB NOT NULL,
AbsoluteExpiration DATETIME NULL,
SlidingExpirationSeconds BIGINT NULL,
LastAccessed DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
);The IDistributedCache Implementation
Here is the full implementation using Dapper:
public class DistributedMariaDbCache : IDistributedCache, IDisposable
{
private readonly IConfiguration _configuration;
private readonly ILogger<DistributedMariaDbCache> _logger;
private bool _disposedValue;
private CancellationTokenSource _cancellationTokenSource = new();
public DistributedMariaDbCache(
IConfiguration configuration,
ILogger<DistributedMariaDbCache> logger)
{
_configuration = configuration;
_logger = logger;
Task.Run(CleanCache, _cancellationTokenSource.Token);
}
private MySqlConnection GetConnection()
{
return new MySqlConnection(_configuration.GetConnectionString("connection"));
}
private async Task CleanCache()
{
var token = _cancellationTokenSource.Token;
while (!token.IsCancellationRequested)
{
using var connection = GetConnection();
await connection.ExecuteAsync(
"DELETE FROM Cache WHERE AbsoluteExpiration < CURRENT_TIMESTAMP");
await Task.Delay(TimeSpan.FromMinutes(5), token);
}
}
public byte[]? Get(string key)
{
using var connection = GetConnection();
return connection.QueryFirstOrDefault<byte[]>(
"SELECT CacheValue FROM Cache WHERE CacheKey = @Key AND (AbsoluteExpiration IS NULL OR AbsoluteExpiration > CURRENT_TIMESTAMP)",
new { Key = key });
}
public async Task<byte[]?> GetAsync(string key, CancellationToken token = default)
{
using var connection = GetConnection();
return await connection.QueryFirstOrDefaultAsync<byte[]>(
"SELECT CacheValue FROM Cache WHERE CacheKey = @Key AND (AbsoluteExpiration IS NULL OR AbsoluteExpiration > CURRENT_TIMESTAMP)",
new { Key = key });
}
public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
{
using var connection = GetConnection();
var expiration = options.AbsoluteExpirationRelativeToNow.HasValue
? DateTime.UtcNow.Add(options.AbsoluteExpirationRelativeToNow.Value)
: options.AbsoluteExpiration?.UtcDateTime;
connection.Execute(
@"INSERT INTO Cache (CacheKey, CacheValue, AbsoluteExpiration) VALUES (@Key, @Value, @Exp)
ON DUPLICATE KEY UPDATE CacheValue = @Value, AbsoluteExpiration = @Exp",
new { Key = key, Value = value, Exp = expiration });
}
public void Remove(string key)
{
using var connection = GetConnection();
connection.Execute("DELETE FROM Cache WHERE CacheKey = @Key", new { Key = key });
}
// Async wrappers omitted for brevity — follow the same pattern as above
public void Dispose()
{
if (!_disposedValue)
{
_cancellationTokenSource.Cancel();
_disposedValue = true;
}
}
}Register the Cache in Program.cs
builder.Services.AddSingleton<IDistributedCache, DistributedMariaDbCache>();Summary
This MariaDB-backed distributed cache implementation gives you a production-ready caching layer that integrates seamlessly with ASP.NET Core's standard IDistributedCache interface. It supports absolute expiration, automatic cleanup, and works with any existing MariaDB/MySQL database — no Redis or Memcached required.