Faactory.Types 2.0.1

.NET Foundation

Small, reusable .NET building blocks.

• Faactory.Types provides small runtime types and encoding utilities.
• 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.

Install only the packages you need:

dotnet add package Faactory.Types
dotnet add package Faactory.Caching
dotnet add package Faactory.Http

Runtime types

Unique identifiers

UniqueId generates compact, URL-safe identifiers using cryptographically secure randomness.

string id = UniqueId.New();
// id_fxOniKPDBAktptggIajv5DyIjBUOVx92

string orderedId = UniqueId.NewTimeOrdered();
// id_019c2f72a841_fxOniKPDBAktptggIajv5DyIjBUOVx92

Time-ordered identifiers contain a Unix timestamp in milliseconds followed by the same 32-character random component.

Composite identifiers

CompositeId combines multiple string values into a single reversible, URL-safe identifier.

var id = new CompositeId( [ "tenant", "resource" ] );
var parsed = CompositeId.Parse( id.ToString() );

Duration

Duration represents a non-negative duration with millisecond precision and supports compact values such as 2h30m and 500ms.

var duration = Duration.FromSeconds( 30 );
Duration.TryParse( "2h30m", out var parsed );

Base64 URL encoding

Base64Encoder produces canonical, unpadded Base64URL strings and accepts both standard Base64 and Base64URL input when decoding.

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.