Baubit.Caching.Extensions 2026.1.1

Baubit.Caching.Extensions

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

Backward-compatible type specializations for Baubit.Caching with concrete ID types (long and Guid).

Why This Package Exists

Baubit.Caching v2025.52+ introduced generic ID types (TId) for maximum flexibility. While this makes the core library more powerful, it adds complexity for simple use cases.

This package bridges the gap by providing concrete type specializations that:

• Maintain backward compatibility for projects using primitive IDs (long, Guid)
• Reduce boilerplate - no generic type parameters on every declaration
• Keep Baubit.Caching's core surface area minimal while supporting common scenarios

Installation

dotnet add package Baubit.Caching.Extensions

Quick Comparison

Generic API (Baubit.Caching)

// Generic - flexible but verbose
OrderedCache<Guid, MyData> cache = new OrderedCache<Guid, MyData>(...);
IOrderedCache<Guid, MyData> myCache = cache;

Specialized API (Baubit.Caching.Extensions)

// Specialized - simpler for common cases
using Baubit.Caching.Extensions.Guid7;

OrderedCache<MyData> cache = new OrderedCache<MyData>(...);
IOrderedCache<MyData> myCache = cache;

What's Included

1. Guid7 Namespace - GuidV7-based IDs

Use when: You need time-ordered, globally unique identifiers.

using Baubit.Caching.Extensions.Guid7;
using Baubit.Caching.Extensions.Guid7.InMemory;
using Baubit.Identity;

var config = new Configuration { MaxL1Capacity = 100 };
var generator = GuidV7Generator.CreateNew();
var l1Store = new Store<string>(generator, loggerFactory);
var l2Store = new Store<string>(generator, loggerFactory);
var metadata = new Metadata(config, loggerFactory);

var cache = new OrderedCache<string>(config, l1Store, l2Store, metadata, loggerFactory);

Types provided:

• OrderedCache<TValue> → OrderedCache<Guid, TValue>
• IOrderedCache<TValue> → IOrderedCache<Guid, TValue>
• IStore<TValue> → IStore<Guid, TValue>
• IMetadata → IMetadata<Guid>
• CacheEnumeratorCollection → CacheEnumeratorCollection<Guid>
• ICacheAsyncEnumeratorFactory<TValue> → ICacheAsyncEnumeratorFactory<Guid, TValue>
• ICacheEnumerator → ICacheEnumerator<Guid>
• InMemory.Store<TValue> → InMemory.Store<Guid, TValue>
• InMemory.Metadata → InMemory.Metadata<Guid>
• InMemory.Entry<TValue> → InMemory.Entry<Guid, TValue>

2. Long Namespace - Sequential Integer IDs

Use when: You need simple, sequential numeric identifiers.

using Baubit.Caching.Extensions.Long;
using Baubit.Caching.Extensions.Long.InMemory;

var config = new Configuration { MaxL1Capacity = 100 };
var l1Store = new Store<string>(loggerFactory);
var l2Store = new Store<string>(loggerFactory);
var metadata = new Metadata(config, loggerFactory);

var cache = new OrderedCache<string>(config, l1Store, l2Store, metadata, loggerFactory);

Types provided:

• OrderedCache<TValue> → OrderedCache<long, TValue>
• IOrderedCache<TValue> → IOrderedCache<long, TValue>
• IStore<TValue> → IStore<long, TValue>
• IMetadata → IMetadata<long>
• CacheEnumeratorCollection → CacheEnumeratorCollection<long>
• ICacheAsyncEnumeratorFactory<TValue> → ICacheAsyncEnumeratorFactory<long, TValue>
• ICacheEnumerator → ICacheEnumerator<long>
• InMemory.Store<TValue> → InMemory.Store<long, TValue>
• InMemory.Metadata → InMemory.Metadata<long>
• InMemory.Entry<TValue> → InMemory.Entry<long, TValue>

Key Differences

ID Generation

Guid7 (GuidV7)

• Auto-generated: Pass IIdentityGenerator to Store constructor
• Time-ordered: IDs naturally sort chronologically
• Globally unique: Safe for distributed systems

var generator = IdentityGenerator.CreateNew();
var store = new Store<string>(generator, loggerFactory);

Long (Sequential)

• Auto-generated: Starts at 1, increments by 1
• Sequential: IDs are monotonically increasing integers
• Compact: Smaller memory footprint than GUIDs

var store = new Store<string>(loggerFactory);  // No generator needed

Migration Guide

From Generic Baubit.Caching

Before:

using Baubit.Caching;

OrderedCache<Guid, MyData> cache = new OrderedCache<Guid, MyData>(...);
IOrderedCache<Guid, MyData> iCache = cache;

After:

using Baubit.Caching.Extensions.Guid7;

OrderedCache<MyData> cache = new OrderedCache<MyData>(...);
IOrderedCache<MyData> iCache = cache;

Namespace Mapping

When NOT to Use This Package

• Custom ID types: If you need int, string, or custom structs as IDs → use Baubit.Caching directly
• Maximum flexibility: If you want full control over generic type parameters → use Baubit.Caching directly
• Mixed ID types: If you need multiple cache types with different IDs in same project → use Baubit.Caching directly

For the Full Story

This package is a thin compatibility layer. For complete documentation, see:

Baubit.Caching Documentation

Topics covered there:

• Architecture and design rationale
• Complete API reference with examples
• Performance characteristics and benchmarks
• Thread safety guarantees
• Multi-consumer streaming patterns
• Async enumeration
• Eviction strategies
• Configuration options

License

MIT License - see LICENSE file for details.

Contributing

Contributions welcome! Please:

1. Read Baubit.Caching's architecture first
2. Keep changes minimal - this is a compatibility layer
3. Maintain 100% test coverage
4. Follow existing code style

Version Compatibility

This package tracks Baubit.Caching versions:

• Baubit.Caching.Extensions 2025.52.x → Baubit.Caching 2025.52.x
• Always use matching versions to avoid breaking changes