DNV.Dapr.Caching 2.2.0

DNV.Dapr.Caching

A .NET library that provides a Dapr-based implementation of Microsoft's IDistributedCache interface, enabling distributed caching using Dapr's state store building blocks.

Overview

This library integrates Dapr's state management capabilities with .NET's distributed caching abstractions, allowing applications to use any Dapr-supported state store (Redis, Cosmos DB, SQL Server, etc.) as a distributed cache backend through a familiar interface.

Target Framework

• .NET 8.0

Features

• IDistributedCache Implementation: Full compatibility with Microsoft's distributed caching abstractions
• Dapr State Store Integration: Leverage any Dapr state store component as cache backend
• TTL Support: Automatic expiration handling using Dapr's TTL metadata
• Sliding Expiration: Support for sliding expiration windows that refresh on access
• Async Operations: Full async/await support with cancellation tokens
• Logging Integration: Built-in logging for cache operations
• Dependency Injection: Easy registration with .NET's DI container

Dependencies

• Dapr.Client
• Microsoft.Extensions.Caching.Abstractions
• Microsoft.Extensions.Logging
• Microsoft.Extensions.Options

Key Components

DaprCache

Implementation of IDistributedCache that uses Dapr's state store APIs for caching operations.

DaprCacheOptions

Configuration options for the Dapr cache implementation:

• ComponentName: Name of the Dapr state store component to use

CacheItem

Internal record representing cached data with TTL and sliding expiration settings.

Usage

Basic Setup

// Register Dapr and the cache service 
services.AddSingleton<DaprClient>(_ => new DaprClientBuilder().Build());
services.AddDaprCache(o => o.ComponentName = "statestore");

// Use IDistributedCache as normal 
public class MyService 
{ 
    private readonly IDistributedCache _cache;

    public MyService(IDistributedCache cache)
    {
        _cache = cache;
    }
    
    public Task<string?> GetDataAsync(string key)
    {
        return _cache.GetStringAsync(key);
    }
    
    public Task SetDataAsync(string key, string value)
    {
        return _cache.SetStringAsync(key, value, TimeSpan.FromMinutes  (30));
    }
}

Supported Operations

Async Operations (Recommended)

• GetAsync(string key) - Retrieve cached item
• SetAsync(string key, byte[] value, DistributedCacheEntryOptions options) - Store item with expiration
• RefreshAsync(string key) - Refresh sliding expiration
• RemoveAsync(string key) - Remove cached item

Synchronous Operations

• Synchronous methods (Get, Set, Refresh, Remove) throw NotImplementedException
• Use async methods for all operations

Expiration Behavior

Absolute Expiration

Items expire at a specific time, calculated from:

• AbsoluteExpirationRelativeToNow: Relative to current time
• AbsoluteExpiration: Specific DateTimeOffset

Sliding Expiration

Items expire after a period of inactivity:

• SlidingExpiration: Resets expiration on each access
• Automatically refreshes TTL when items are retrieved or refreshed

No Expiration

Items without expiration settings are stored indefinitely (TTL = -1).

Dapr Component Configuration

Ensure your Dapr state store component supports TTL metadata:

apiVersion: dapr.io/v1alpha1 
kind: Component 
metadata: 
  name: statestore 
spec: 
  type: state.redis 
  version: v1 
  metadata:
  - name: redisHost 
    value: localhost:6379
  - name: redisPassword 
    value: ""
  - name: enableTLS 
    value: false

Logging

The cache implementation includes structured logging for all operations:

• Cache retrievals: "Retrieving cache item: {key}"
• Cache storage: "Saving cache item: {key}"
• Cache removal: "Removing cache item: {key}"
• Cache refresh: "Refreshing cache item: {key}"

Limitations

• Synchronous methods are not implemented (by design for async-first approach)
• TTL precision depends on the underlying Dapr state store component
• Cache size limits depend on the configured state store backend

Author

Eric Liu li.eric.liu@dnv.com