Cache distribuído local com LiteDB e IDistributedCache no .NET

Introdução

O IDistributedCache é uma interface poderosa da plataforma .NET que permite abstrair o uso de cache distribuído em aplicações web, APIs e serviços. As implementações mais comuns incluem Redis ou SQL Server, mas e quando queremos algo mais leve, local e com persistência?

Neste artigo, apresento a biblioteca CSharpBrasil.Extensions.Caching.LiteDb, uma solução desenvolvida para oferecer caching distribuído local com o banco LiteDB — um banco NoSQL leve e embutido em C#.

Por que usar LiteDB como backend de cache?

  • Sem dependências externas: ideal para aplicações em containers, APIs internas e soluções desktop.
  • Desempenho local otimizado: armazena os dados em um único arquivo .db, com leitura simultânea e escrita isolada por coleção.
  • Controle completo: opções de segurança, rebuild, collation e cache cleanup automático.

Instalação

Instale via NuGet:

1

dotnet add package CSharpBrasil.Extensions.Caching.LiteDb

Configuração da biblioteca

A biblioteca implementa IDistributedCache e pode ser injetada com facilidade em qualquer aplicação .NET via IServiceCollection:

1
2
3
4
5
6
7
8

builder.Services.AddLiteDbDistributedCache(options =>
{
    options.DatabasePath = "cache.db";
    options.CollectionName = "cache";
    options.Password = "sua-senha-opcional";
    options.CleanupInterval = TimeSpan.FromMinutes(10);
    options.EnableAutoCleanup = true;
});

Opções disponíveis

1
2
3
4
5
6
7
8
9
10
11
12
13

public class LiteDbDistributedCacheOptions
{
    public string DatabasePath { get; set; } = "cache.db";
    public string CollectionName { get; set; } = "cache";
    public bool EnableAutoCleanup { get; set; } = true;
    public TimeSpan CleanupInterval { get; set; } = TimeSpan.FromMinutes(10);
    public bool ReadOnly { get; set; } = false;
    public string? Password { get; set; }
    public bool Upgrade { get; set; } = false;
    public bool AutoRebuild { get; set; } = false;
    public long InitialSize { get; set; } = 0;
    public Collation Collation { get; set; } = Collation.Default;
}

Exemplo de uso em API

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

[ApiController]
[Route("api/cache")]
public class CacheController : ControllerBase
{
    private readonly IDistributedCache _cache;

    public CacheController(IDistributedCache cache)
    {
        _cache = cache;
    }

    [HttpPost("{key}")]
    public async Task<IActionResult> Set(string key, [FromBody] string value)
    {
        await _cache.SetStringAsync(key, value, new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
        });
        return Ok();
    }

    [HttpGet("{key}")]
    public async Task<IActionResult> Get(string key)
    {
        var value = await _cache.GetStringAsync(key);
        return Ok(value ?? "(not found)");
    }
}

Exemplo de uso em Console App

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

var host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.AddLiteDbDistributedCache(options =>
        {
            options.DatabasePath = "console-cache.db";
        });
    })
    .Build();

var cache = host.Services.GetRequiredService<IDistributedCache>();

await cache.SetStringAsync("message", "Olá mundo!", new DistributedCacheEntryOptions
{
    AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(30)
});

var result = await cache.GetStringAsync("message");
Console.WriteLine($"Mensagem em cache: {result}");

Considerações finais

Essa biblioteca foi pensada para aplicações reais que precisam de caching local performático, com segurança e controle total sobre a persistência dos dados. O LiteDB é uma excelente alternativa quando não se quer depender de um Redis ou infraestrutura externa.

Acesse o código no GitHub e instale o pacote no NuGet para começar a usar agora mesmo!

Participe da nossa comunidade no WhastApp.

Bons estudos e mãos à obra!