PostgreSQL-backed Distributed Caching for .NET

// Inject IGlacialCache (extends IDistributedCache)
public class ProductService
{
    private readonly IGlacialCache _cache;
    
    public ProductService(IGlacialCache cache) => _cache = cache;

    // Batch GET - Single database round-trip for multiple keys
    public async Task<List<Product>> GetProductsAsync(int[] ids)
    {
        var keys = ids.Select(id => $"product:{id}");
        var results = await _cache.GetMultipleAsync(keys);
        
        return results.Values
            .Where(v => v != null)
            .Select(v => JsonSerializer.Deserialize<Product>(v))
            .ToList();
    }

    // Batch SET - Efficient bulk insertion
    public async Task CacheProductsAsync(List<Product> products)
    {
        var entries = products.ToDictionary(
            p => $"product:{p.Id}",
            p => (
                value: Encoding.UTF8.GetBytes(JsonSerializer.Serialize(p)),
                options: new DistributedCacheEntryOptions {
                    SlidingExpiration = TimeSpan.FromMinutes(30)
                }
            )
        );
        
        await _cache.SetMultipleAsync(entries);
    }

    // Also available: RemoveMultipleAsync, RefreshMultipleAsync
}

// Inject IGlacialCache for advanced features
public class UserService
{
    private readonly IGlacialCache _cache;
    
    public UserService(IGlacialCache cache) => _cache = cache;

    // Typed GET with automatic deserialization
    public async Task<User?> GetUserAsync(int userId)
    {
        var entry = await _cache.GetEntryAsync<User>($"user:{userId}");
        return entry?.Value; // Strongly typed!
    }

    // Typed SET with automatic serialization
    public async Task CacheUserAsync(User user)
    {
        await _cache.SetEntryAsync($"user:{user.Id}", user, new() {
            SlidingExpiration = TimeSpan.FromMinutes(30),
            AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(2)
        });
    }

    // Batch typed operations
    public async Task<List<User>> GetUsersAsync(int[] userIds)
    {
        var keys = userIds.Select(id => $"user:{id}");
        var entries = await _cache.GetMultipleEntriesAsync<User>(keys);
        
        return entries.Values
            .Where(e => e?.Value != null)
            .Select(e => e.Value)
            .ToList();
    }

    // Set multiple typed entries
    public async Task CacheUsersAsync(List<User> users)
    {
        var entries = users.ToDictionary(
            u => $"user:{u.Id}",
            u => (value: u, options: (DistributedCacheEntryOptions?)new() {
                SlidingExpiration = TimeSpan.FromMinutes(30)
            })
        );
        
        await _cache.SetMultipleEntriesAsync(entries);
    }
}