Faactory.Http 0.1.0

.NET Foundation

Small, reusable .NET building blocks.

• Faactory.Caching provides a typed object cache over IDistributedCache, including negative entries.
• Faactory.Http provides named HTTP clients with object caching and optional request authorization.

Object caching

Register an IDistributedCache implementation, then add the object cache:

services.AddDistributedMemoryCache();

services.AddDistributedObjectCache( options =>
{
    options.DefaultAbsoluteExpiration = TimeSpan.FromMinutes( 1 );
    options.DefaultNegativeAbsoluteExpiration = TimeSpan.FromSeconds( 5 );
} );

IObjectCache.GetAsync<T> returns null for a cache miss. A non-null ObjectCacheEntry<T> represents a cached result; IsNegative indicates a cached absence.

var cached = await objectCache.GetAsync<Device>( key, cancellationToken );

if ( cached is not null )
{
    return cached.Value;
}

var device = await repository.GetDeviceAsync( id, cancellationToken );

if ( device is null )
{
    await objectCache.SetNegativeAsync<Device>( key, cancellationToken: cancellationToken );
    return null;
}

await objectCache.SetAsync( key, device, cancellationToken: cancellationToken );
return device;

Use a shared IDistributedCache provider when entries must survive application restarts or be shared between instances.

Cached HTTP clients

Register a named cached client using the normal HttpClient configuration model:

services
    .AddCachedHttpClient( "devices", ( serviceProvider, httpClient ) =>
    {
        httpClient.BaseAddress = new Uri( "https://devices.example/" );
    } )
    .ConfigureCachedHttpClient( options =>
    {
        options.TransientNegativeAbsoluteExpirationRelativeToNow =
            TimeSpan.FromSeconds( 5 );
    } );

Create clients through ICachedHttpClientFactory:

var client = cachedHttpClientFactory.CreateClient( "devices" );

var device = await client.GetAsync<Device>(
    $"device:{deviceId}",
    $"/api/devices/{deviceId}",
    device => device.Enabled,
    cancellationToken
);

GetAsync<T> returns a cached value when available. Missing or unacceptable objects are negatively cached. Selected transient HTTP failures are cached briefly; other failures return null without being cached. Cache failures do not prevent the HTTP lookup from succeeding.

Implement IAuthorizationProvider when requests need dynamic authorization. The provider receives the complete HttpRequestMessage and may apply any authorization scheme, header, query value, or signature.

Cached values are shared by cache key. Do not use a cached client for caller-specific responses unless the cache key includes the relevant tenant, user, or authorization scope.