GoatFam.AzureRedisCache 1.0.0

AzureRedisCache

A .NET Standard 2.1 library that provides a wrapper service for Azure Redis Cache with built-in serialization.

Features

• Set and get cached data with automatic serialization/deserialization - Store and retrieve complex objects with automatic JSON serialization, eliminating manual serialization code
• Support for custom cache expiration policies - Configure flexible expiration strategies including absolute, sliding, and custom time-to-live (TTL) values
• Distributed cache interface implementation - Fully compatible with IDistributedCache interface for seamless integration with ASP.NET Core caching
• Result pattern for cache operations - Use the Result<T> pattern to handle cache operations with explicit success/failure states and error messages

Getting Started

Prerequisites

• .NET Standard 2.1 compatible runtime (.NET Core 3.1+, .NET 5+, .NET 6+, .NET 8+)
• Azure Redis Cache instance
• StackExchange.Redis library (included as dependency)

Installation

Install the NuGet package in your project:

dotnet add package AzureRedisCache

Or add it via Package Manager:

Install-Package AzureRedisCache

For local development, reference the project directly:

<ProjectReference Include="..\..\src\AzureRedisCache\AzureRedisCache.csproj" />

Configuration

Add Azure Redis Cache configuration to your appsettings.json:

{
  "RedisOptions": {
    "Configuration": "your-redis-cache.redis.cache.windows.net:6380,password=your-access-key,ssl=True,abortConnect=False",
    "InstanceName": "your-app-name:"
  }
}

Registration

Register the service in your Program.cs or Startup.cs:

using AzureRedisCache.Extensions;

// Register with default configuration
builder.Services.AddAzureRedisWithOptions();

Basic Usage

using AzureRedisCache.Services;
using AzureRedisCache.Models;

public class ProductService
{
    private readonly IWrapperCacheService _cacheService;
    
    public ProductService(IWrapperCacheService cacheService)
    {
        _cacheService = cacheService;
    }
    
    // Cache a complex object
    public async Task CacheProductAsync(string productId, Product product)
    {
        var cacheKey = $"product:{productId}";
        var expiry = TimeSpan.FromHours(1);
        
        var result = await _cacheService.SetRecordAsync(cacheKey, product, expiry);
        
        if (!result.IsSuccess)
        {
            // Handle cache failure
            Console.WriteLine($"Cache failed: {result.ErrorMessage}");
        }
    }
    
    // Retrieve from cache with Result pattern
    public async Task<Product> GetProductAsync(string productId)
    {
        var cacheKey = $"product:{productId}";
        var result = await _cacheService.GetRecordAsync<Product>(cacheKey);
        
        if (result.IsSuccess)
        {
            return result.Value;
        }
        
        // Cache miss or error - fetch from database
        return await FetchProductFromDatabaseAsync(productId);
    }
}

Advanced Usage

// Using Result pattern for error handling
public async Task<Result<Product>> GetCachedProductAsync(string productId)
{
    var cacheKey = $"product:{productId}";
    return await _cacheService.GetRecordAsync<Product>(cacheKey);
}

// Custom expiration
var slidingExpiration = TimeSpan.FromMinutes(30);
await _cacheService.SetRecordAsync("key", value, slidingExpiration);

// Check result status
var result = await _cacheService.GetRecordAsync<Product>("product:123");
if (result.IsSuccess)
{
    Console.WriteLine($"Found product: {result.Value.Name}");
}
else
{
    Console.WriteLine($"Error: {result.ErrorMessage}");
}

Result Pattern

The library uses the Result<T> pattern for explicit error handling:

public class Result<T>
{
    public bool IsSuccess { get; set; }
    public T Value { get; set; }
    public string ErrorMessage { get; set; }
}

This pattern allows you to:

• Distinguish between expected failures (cache miss) and unexpected errors
• Handle errors explicitly without exceptions
• Chain operations safely

Documentation

For detailed patterns and examples:

• docs/coding-patterns.md - Result pattern and distributed cache interface
• docs/sample-applications.md - Integration examples
• examples/ArticleManagementAPI - Working implementation with caching

License

This project is licensed under the MIT License.