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

Por Raphael Cardoso1 min de leitura
Neste artigo
  1. Introdução
  2. Por que usar LiteDB como backend de cache?
  3. Instalação
  4. Configuração da biblioteca
  5. Opções disponíveis
  6. Exemplo de uso em API
  7. Exemplo de uso em Console App
  8. Considerações finais

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:

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:

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

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

[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

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!