Baubit.Caching.DI 2026.4.1

Baubit.Caching.DI

<br/> <br/> <br/>

Dependency injection modules for Baubit.Caching. Registers IOrderedCache<TId, TValue> in your DI container with configurable L1/L2 caching and service lifetimes.

Important: When using configuration-based module loading with concrete (non-generic) modules, you MUST call YourModuleRegistry.Register() before UseConfiguredServiceProviderFactory(). See Configuration-Based Loading for details.

Installation

dotnet add package Baubit.Caching.DI

Quick Start

Programmatic Module Loading

Load caching modules programmatically using IComponent. This is the recommended approach for generic cache modules.

using Baubit.Caching.DI;
using Baubit.DI;
using Baubit.DI.Extensions;
using Microsoft.Extensions.DependencyInjection;

public class AppComponent : Component
{
    protected override Result<ComponentBuilder> Build(ComponentBuilder builder)
    {
        return builder.WithModule<InMemory.Guid7.Module<string>, InMemory.Configuration>(config =>
        {
            config.IncludeL1Caching = true;
            config.L1MinCap = 128;
            config.L1MaxCap = 8192;
            config.CacheLifetime = ServiceLifetime.Singleton;
        }, config => new InMemory.Guid7.Module<string>(config));
    }
}

await Host.CreateEmptyApplicationBuilder(new HostApplicationBuilderSettings())
          .UseConfiguredServiceProviderFactory(componentsFactory: () => [new AppComponent()])
          .Build()
          .RunAsync();

Configuration-Based Loading

Create a concrete module by extending one of the generic modules and decorating it with [BaubitModule].

Step 1: Create a Concrete Module

using Baubit.Caching.DI;
using Baubit.DI;
using Microsoft.Extensions.Configuration;
using System.Collections.Generic;

namespace MyApp.Caching
{
    [BaubitModule("string-cache")]
    public class StringCacheModule : InMemory.Guid7.Module<string>
    {
        public StringCacheModule(IConfiguration configuration) : base(configuration) { }
        
        public StringCacheModule(InMemory.Configuration configuration, List<IModule> nestedModules = null) 
            : base(configuration, nestedModules) { }
    }
}

Step 2: Create Module Registry

using Baubit.DI;

namespace MyApp.Caching
{
    [GeneratedModuleRegistry]
    internal static partial class CachingModuleRegistry
    {
        // Register() method will be generated automatically
    }
}

Step 3: Register and Load

CRITICAL: You MUST call Register() on your module registry before any module loading operations. Forgetting this step will cause your modules to not be found and can lead to frustrating runtime errors.

using MyApp.Caching;

// MUST be called before UseConfiguredServiceProviderFactory()
CachingModuleRegistry.Register();

await Host.CreateApplicationBuilder()
          .UseConfiguredServiceProviderFactory()
          .Build()
          .RunAsync();

Step 4: Configure in appsettings.json

{
  "modules": [
    {
      "key": "string-cache",
      "configuration": {
        "includeL1Caching": true,
        "l1MinCap": 128,
        "l1MaxCap": 8192,
        "cacheLifetime": "Singleton"
      }
    }
  ]
}

Hybrid Loading

Combine with other modules from appsettings.json:

using MyApp.Caching;

// MUST call Register() first
CachingModuleRegistry.Register();

await Host.CreateApplicationBuilder()
          .UseConfiguredServiceProviderFactory(componentsFactory: () => [new AppComponent()])
          .Build()
          .RunAsync();

Keyed Service Registration

Register multiple cache instances with different keys for different use cases.

using Baubit.Caching.DI;
using Baubit.DI;
using Microsoft.Extensions.DependencyInjection;

public class AppComponent : Component
{
    protected override Result<ComponentBuilder> Build(ComponentBuilder builder)
    {
        return builder.WithModule<InMemory.Module<long, string>, InMemory.Configuration>(config =>
                      {
                          config.RegistrationKey = "user-cache";
                          config.CacheLifetime = ServiceLifetime.Singleton;
                      }, config => new InMemory.Module<long, string>(config))
                      .WithModule<InMemory.Module<long, string>, InMemory.Configuration>(config =>
                      {
                          config.RegistrationKey = "product-cache";
                          config.CacheLifetime = ServiceLifetime.Singleton;
                      }, config => new InMemory.Module<long, string>(config));
    }
}

// Resolve keyed services
var userCache = serviceProvider.GetKeyedService<IOrderedCache<long, string>>("user-cache");
var productCache = serviceProvider.GetKeyedService<IOrderedCache<long, string>>("product-cache");

Features

• L1/L2 Caching: Optional bounded L1 layer with unbounded L2 storage
• Configurable Lifetimes: Singleton, Transient, or Scoped registration
• Keyed Service Registration: Register multiple cache instances with unique keys
• Type-Safe Configuration: Strongly-typed configuration via IComponent
• Sequential ID Generation: Long and GUID v7 ID generators included

Configuration

Available Modules

InMemory.Long.Module<TValue>

In-memory cache module with sequential long ID generation starting from 1.

InMemory.Guid7.Module<TValue>

In-memory cache module with monotonically increasing GUID v7 ID generation.

Keyed Service Registration

Register multiple cache instances with different keys:

public class AppComponent : Component
{
    protected override Result<ComponentBuilder> Build(ComponentBuilder builder)
    {
        return builder.WithModule<InMemory.Guid7.Module<string>, InMemory.Configuration>(config =>
                      {
                          config.RegistrationKey = "user-cache";
                          config.CacheLifetime = ServiceLifetime.Singleton;
                      }, config => new InMemory.Guid7.Module<string>(config))
                      .WithModule<InMemory.Guid7.Module<string>, InMemory.Configuration>(config =>
                      {
                          config.RegistrationKey = "product-cache";
                          config.CacheLifetime = ServiceLifetime.Singleton;
                      }, config => new InMemory.Guid7.Module<string>(config));
    }
}

// Resolve keyed services
var userCache = serviceProvider.GetKeyedService<IOrderedCache<Guid, string>>("user-cache");
var productCache = serviceProvider.GetKeyedService<IOrderedCache<Guid, string>>("product-cache");

Creating Custom Modules

Extend Module<TId, TValue, TConfiguration> to create custom cache modules with different storage backends or ID generation strategies.

Required Overrides

When creating a custom module, you must implement three abstract methods:

• BuildL1DataStore(IServiceProvider): Creates the L1 (bounded) cache store
• BuildL2DataStore(IServiceProvider): Creates the L2 (unbounded) cache store
• BuildMetadata(IServiceProvider): Creates the metadata store for cache statistics

Optional Overrides

Two virtual methods are available for advanced customization:

• BuildCacheEnumeratorCollectionFactory(IServiceProvider): Customize how enumerator collections are created (default: () => new CacheEnumeratorCollection<TId>())
• BuildCacheEnumeratorFactory(IServiceProvider): Customize the async enumerator factory (default: new CacheAsyncEnumeratorFactory<TId, TValue>())

Example: Custom Module

using Baubit.Caching;
using Baubit.Caching.DI;
using Baubit.DI;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;

namespace MyApp.Caching
{
    public class RedisConfiguration : Configuration
    {
        public string ConnectionString { get; set; }
        public int DatabaseNumber { get; set; } = 0;
    }

    public abstract class RedisModule<TId, TValue> : Module<TId, TValue, RedisConfiguration> 
        where TId : struct, IComparable<TId>, IEquatable<TId>
    {
        protected RedisModule(RedisConfiguration configuration, List<IModule> nestedModules = null) 
            : base(configuration, nestedModules) { }

        protected override IStore<TId, TValue> BuildL1DataStore(IServiceProvider serviceProvider)
        {
            // Implement Redis-backed L1 store
            throw new NotImplementedException();
        }

        protected override IStore<TId, TValue> BuildL2DataStore(IServiceProvider serviceProvider)
        {
            // Implement Redis-backed L2 store
            throw new NotImplementedException();
        }

        protected override IMetadata<TId> BuildMetadata(IServiceProvider serviceProvider)
        {
            // Implement Redis-backed metadata store
            throw new NotImplementedException();
        }

        // Optional: Override to customize cache enumerator collection factory
        protected override Func<CacheEnumeratorCollection<TId>> BuildCacheEnumeratorCollectionFactory(IServiceProvider serviceProvider)
        {
            // Default implementation returns () => new CacheEnumeratorCollection<TId>()
            return base.BuildCacheEnumeratorCollectionFactory(serviceProvider);
        }

        // Optional: Override to customize cache async enumerator factory
        protected override ICacheAsyncEnumeratorFactory<TId, TValue> BuildCacheEnumeratorFactory(IServiceProvider serviceProvider)
        {
            // Default implementation returns new CacheAsyncEnumeratorFactory<TId, TValue>()
            return base.BuildCacheEnumeratorFactory(serviceProvider);
        }
    }
}

Dependencies

• Baubit.Caching - Core caching abstractions
• Baubit.DI.Extensions - Dependency injection modularity framework

License

MIT