RetailSolutions.Shared.Cache 1.3.1400

RetailSolutions.Shared.Cache

Unified caching abstraction for .NET 10 applications with support for Redis and In-Memory backends, automatic environment detection, and distributed locks via RedLock.net.

Installation

dotnet add package RetailSolutions.Shared.Cache

Or via Package Manager Console:

Install-Package RetailSolutions.Shared.Cache

Requirements

• .NET 10.0+
• Redis instance (only required when using Redis backend)

Quick Start

Register the cache service in your application startup:

var builder = WebApplication.CreateBuilder(args);

var cacheSettings = builder.Configuration.GetSection("Cache").Get<CacheSettings>()
    ?? new CacheSettings();

builder.Services.AddCache(cacheSettings);

var app = builder.Build();
app.UseCache(); // validates Redis connectivity before startup

app.Run();

Inject ICacheService wherever caching is needed:

public class ProductService(ICacheService cache)
{
    public async Task<Product> GetProductAsync(string id) =>
        await cache.GetOrSetAsync(
            $"product:{id}",
            () => repository.GetByIdAsync(id),
            TimeSpan.FromMinutes(30)
        );
}

Configuration

appsettings.json

{
  "Cache": {
    "CacheType": "Auto",
    "Redis": {
      "ConnectionString": "localhost:6379",
      "InstanceName": "myapp"
    },
    "Memory": {
      "SizeLimit": 10240,
      "DefaultExpiration": "00:30:00"
    },
    "Expirations": [
      { "Key": "product:*", "Expiration": "01:00:00" },
      { "Key": "session:*", "Expiration": "00:15:00" }
    ]
  }
}

Environment Detection (Auto mode)

If Redis is configured but unreachable, the library automatically falls back to Memory Cache.

ICacheService API

Startup Validation

UseCache() performs a write/read/delete health check against Redis before the application starts. It throws if the check fails, preventing startup with a broken cache connection. Ignored when using Memory Cache.

app.UseCache(); // throws on Redis connectivity failure

Distributed Locks

Register RedLock.net support separately:

builder.AddRedisLock(
    builder.Configuration.GetConnectionString("Redis"),
    "my-application-name"
);

Use IDistributedLockFactory to acquire distributed locks:

public class OrderService(IDistributedLockFactory lockFactory)
{
    public async Task ProcessOrderAsync(string orderId)
    {
        await using var redLock = await lockFactory.CreateLockAsync(
            $"order:{orderId}",
            expiryTime: TimeSpan.FromSeconds(30)
        );

        if (!redLock.IsAcquired)
            throw new InvalidOperationException("Order is already being processed.");

        await ProcessAsync(orderId);
    }
}

Dependencies

License

Copyright © Retail Solutions