The user wants a simple C# cache container. Let me write a clean, practical implementation with the common features you'd expect: 1. Generic `Get` / `Set` / `TryGet` methods 2. Expiration (TTL - time to live) 3. Thread safety 4. Maybe eviction or cleanup Let me design a simple but functional cache: **Core features:** - `Get(key)` - retrieve item - `Set(key, value, expiration)` - store item - `TryGet(key, out value)` - safe retrieval - `Remove(key)` - explicit removal - `Clear()` - wipe all - `Count` - number of items - Lazy expiration (expired items removed when accessed) + periodic cleanup option - Thread-safe using `ConcurrentDictionary` and locks where needed Let me write a clean implementation: ```csharp using System; using System.Collections.Concurrent; public class CacheContainer { private class CacheEntry { public TValue Value { get; set; } public DateTimeOffset ExpiresAt { get; set; } public bool IsExpired => DateTimeOffset.UtcNow >= ExpiresAt; } private readonly ConcurrentDictionary> _cache = new(); private readonly TimeSpan _defaultExpiration; ... } ``` Actually, let me keep it simple — the user asked for a "simple" cache container. I shouldn't over-engineer. But it should be genuinely useful: thread-safe, with expiration, and demonstrate usage. Two design choices: 1. Generic key + generic typed values (`Get` pattern like MemoryCache) — allows heterogeneous values 2. Strongly-typed `TKey, TValue` cache Option 2 is simpler and more type-safe. Let me go with `TKey, TValue` since it's "simple", but I could mention the alternative. Let me write it: ```csharp using System; using System.Collections.Concurrent; public class SimpleCache where TKey : notnull { private sealed class CacheEntry { public required TValue Value { get; init; } public DateTimeOffset ExpiresAt { get; init; } public bool IsExpired => DateTimeOffset.UtcNow >= ExpiresAt; } private readonly ConcurrentDictionary _entries = new(); private readonly TimeSpan _defaultTtl; private readonly object _cleanupLock = new(); private DateTimeOffset _lastCleanup = DateTimeOffset.UtcNow; private readonly TimeSpan _cleanupInterval = TimeSpan.FromMinutes(1); public SimpleCache(TimeSpan? defaultTtl = null) { _defaultTtl = defaultTtl ?? TimeSpan.FromMinutes(5); } public int Count => _entries.Count; public void Set(TKey key, TValue value, TimeSpan? ttl = null) { MaybeCleanup(); _entries[key] = new CacheEntry { Value = value, ExpiresAt = DateTimeOffset.UtcNow + (ttl ?? _defaultTtl) }; } public bool TryGet(TKey key, out TValue? value) { if (_entries.TryGetValue(key, out var entry) && !entry.IsExpired) { value = entry.Value; return true; } // Remove stale entry _entries.TryRemove(key, out _); value = default; return false; } public TValue? Get(TKey key) => TryGet(key, out var value) ? value : default; public TValue GetOrAdd(TKey key, Func factory, TimeSpan? ttl = null) { if (TryGet(key, out var existing)) return existing!; var value = factory(key); Set(key, value, ttl); return value; } public bool Remove(TKey key) => _entries.TryRemove(key, out _); public void Clear() => _entries.Clear(); private void MaybeCleanup() { // Cheap opportunistic cleanup — avoid sweeping on every write var now = DateTimeOffset.UtcNow; if ((now - _lastCleanup) < _cleanupInterval) return; lock (_cleanupLock) { if ((DateTimeOffset.UtcNow - _lastCleanup) < _cleanupInterval) return; _lastCleanup = DateTimeOffset.UtcNow; } foreach (var kvp in _entries) { if (kvp.Value.IsExpired) _entries.TryRemove(kvp.Key, out _); } } } ``` Hmm, there's a subtle race in MaybeCleanup — between the initial check and the lock, the _lastCleanup read outside lock is a benign race. Actually the double-check pattern: first read outside lock (fast path), then inside lock re-check. The outer read of _lastCleanup isn't volatile but it's fine for a cache cleanup — worst case we skip or do an extra sweep. Actually for correctness let me make it slightly cleaner. Actually it's fine — cleanup is opportunistic. One issue with GetOrAdd: factory could be called multiple times under concurrency (classic cache stampede). For a "simple" cache that's acceptable; I can note it. Using Lazy prevents it but adds complexity. Maybe mention it briefly. Also there's a race in TryGet where an expired entry might be added back between TryGetValue and TryRemove — TryRemove could remove a fresh entry if someone Set it in between. Edge case: entry expired, we read it, someone Set a new value with same key, then we TryRemove and remove the fresh value. To handle that properly, use an overload of TryRemove with a predicate or compare values. `ConcurrentDictionary.TryRemove(key, out _)` removes whatever's there. There's `TryRemove(KeyValuePair)` in .NET 5+ which removes only if the value matches. I could use `_entries.TryRemove(new KeyValuePair(key, entry))`. That's .NET 5+. To keep it broadly compatible, I could just accept the tiny race, or use the KVP overload. Let me use the KVP overload and note it requires .NET 5+, or just keep simple. For a "simple" cache, I'll keep it simple and maybe mention the edge case briefly. Actually the KVP overload is clean and available in modern .NET; let me use it with a comment. Also usage example and a note about IMemoryCache for production. Also `TValue?` with nullable annotations — with `where TValue : class`? No, don't constrain. Using `out TValue? value` and returning `default` — fine with nullable reference types enabled; if disabled, no `?`. I'll include `#nullable enable` note or just write it cleanly. Let me write with nullable annotations since modern C# has them on by default in templates. Also should Count exclude expired? Count returns raw count including expired-but-not-yet-cleaned. I could compute live count but that's O(n). For simple, just document it, or make Count sweep first? Let me just have Count return the dictionary size and mention expired entries linger until cleanup. Or provide a `Count` that runs cleanup... Keep simple: note it. Let me also add a `GetOrCreate`... GetOrAdd covers it. Thread-safety notes: ConcurrentDictionary handles the storage; each method is atomic enough individually; GetOrAdd may invoke factory multiple times under race. Let me also show usage: ```csharp var cache = new SimpleCache(defaultTtl: TimeSpan.FromMinutes(10)); cache.Set("user:42", new UserProfile("Ada"), TimeSpan.FromMinutes(5)); cache.Set("user:7", new UserProfile("Grace")); // default TTL if (cache.TryGet("user:42", out var user)) Console.WriteLine(user!.Name); var settings = cache.GetOrAdd("settings", LoadSettingsFromDb); ``` Also maybe demo expiration with Thread.Sleep in a small Program. Format: Code-heavy answer. A brief intro line, the code block, short usage example, and a few bullet notes on design decisions / limitations (thread safety, lazy cleanup, GetOrAdd race, production alternative = IMemoryCache / Microsoft.Extensions.Caching.Memory). Keep prose minimal. Use headers sparingly — maybe just the code blocks with short labels. Markdown is appropriate since this renders in chat. Length: the code is the bulk. Keep notes tight. Let me finalize the code. Also consider: should I make it non-generic-key (string keys) to be simpler? Generic TKey,TValue is standard and not much extra. Keep generic. One more thing: `required` keyword needs C# 11. To keep compatibility, use constructor or just mutable props. I'll use a simple constructor to avoid `required`: ```csharp private sealed class CacheEntry { public CacheEntry(TValue value, DateTimeOffset expiresAt) { Value = value; ExpiresAt = expiresAt; } public TValue Value { get; } public DateTimeOffset ExpiresAt { get; } public bool IsExpired => DateTimeOffset.UtcNow >= ExpiresAt; } ``` Good — immutable entries, no `required`. For TryRemove with KVP: signature is `TryRemove(KeyValuePair item)` — actually it's `TryRemove(KeyValuePair)` on ConcurrentDictionary in .NET 5+. Wait, the parameter type is `KeyValuePair`, yes. So `_entries.TryRemove(new KeyValuePair(key, entry))` returns true only if entry still matches (reference equality for classes since CacheEntry is a class — KVP equality uses EqualityComparer.Default; for a class without Equals override that's reference equality — good). Hmm, does the KVP overload compare key too? Yes — it removes the entry if the key exists AND the value equals. Good. But for broader compatibility (e.g., .NET Framework), maybe simpler to just call TryRemove(key, out _). The stale-removal race is minor for a "simple" cache. I'll use the KVP overload with a brief comment saying it avoids removing a freshly-replaced value; if targeting older frameworks, swap to TryRemove(key, out _). Actually that might be too much detail. I'll include one short comment inline. Let me also double check MaybeCleanup double-checked locking: `_lastCleanup` is a DateTimeOffset — not atomic? DateTimeOffset is a struct of DateTime + TimeSpan/short; reads aren't guaranteed atomic (struct larger than word). Racy reads could see torn values in theory. To be safe and simple, use a `long` (ticks) with Interlocked or just volatile long read via Interlocked.CompareExchange. Simpler: use `DateTimeOffset _lastCleanup` guarded... torn reads are practically unlikely but let's be correct: store as `long _lastCleanupTicks` and use `Interlocked.Read` / plain long reads. On 64-bit, long reads are atomic; on 32-bit not guaranteed. Use Interlocked.CompareExchange to both read-and-set atomically: ```csharp private long _lastCleanupTicks; private void MaybeCleanup() { var nowTicks = DateTimeOffset.UtcNow.UtcTicks; var last = Interlocked.Read(ref _lastCleanupTicks); if (nowTicks - last < _cleanupInterval.Ticks) return; var prev = Interlocked.CompareExchange(ref _lastCleanupTicks, nowTicks, last); if (prev != last) return; // someone else is cleaning foreach (var kvp in _entries) if (kvp.Value.IsExpired) _entries.TryRemove(kvp.Key, out _); } ``` Wait, Interlocked.Read only works with long (yes, Interlocked.Read(ref long)). This is clean CAS-based throttling. But is this too clever for a "simple" cache? It's a good pattern and only a few lines. I'll include it but keep comments light. Hmm, actually maybe simpler and still correct: keep a lock-free approach with just Interlocked on a long. The above is fine. Actually, even simpler for readability: ```csharp private void MaybeCleanup() { var now = DateTimeOffset.UtcNow.UtcTicks; if (now - Volatile.Read(ref _lastCleanupTicks) < _cleanupIntervalTicks) return; if (Interlocked.Exchange(ref _lastCleanupTicks, now) ... ) ``` The Exchange version: first thread exchanges last->now and proceeds; others see recent value and skip. But Exchange unconditionally sets; if two threads pass the initial check at the same time, both call Exchange; the first gets old value and proceeds; second gets the value just set (== its own `now` approx) and would compare against interval — need to check: second thread's Exchange returns the new ticks which is within interval of its own now? The first thread set `now1`; second reads via Exchange and gets `now1`; then it should check if `now2 - now1 < interval` and abort. So: ```csharp long last = Interlocked.Exchange(ref _lastCleanupTicks, now); if (now - last < _cleanupIntervalTicks) return; // someone cleaned recently // sweep ``` Wait but that inverts: if now - last >= interval we sweep. First thread: last is old, now-last big → sweeps. Second thread: Exchange already updated by first to now1; now2 - now1 tiny → skips. But the first thread's Exchange itself set ticks to now1 unconditionally, even if it ends up... no wait, first thread passed initial check meaning now1 - last_old >= interval. Fine. This is simpler than CAS. Edge: a thread that fails the initial check never touches ticks. Good. But unconditional Exchange by a thread that passed the initial check is fine because initial check already guaranteed interval elapsed. Actually careful: thread B's initial check passed (now2 - last >= interval) but between check and Exchange, thread A swept and set ticks=now1. Then B does Exchange(now2), returns now1, sees now2-now1 < interval → skips sweep. Ticks got updated to now2 — harmless. So: ```csharp private long _lastCleanupTicks = DateTimeOffset.UtcNow.UtcTicks; private void MaybeCleanup() { long now = DateTimeOffset.UtcNow.UtcTicks; if (now - Volatile.Read(ref _lastCleanupTicks) < _cleanupIntervalTicks) return; long previous = Interlocked.Exchange(ref _lastCleanupTicks, now); if (now - previous < _cleanupIntervalTicks) return; // another thread just swept foreach (var kvp in _entries) if (kvp.Value.IsExpired) _entries.TryRemove(kvp.Key, out _); } ``` Hmm wait — there's a subtle bug: a thread that passed the initial check exchanges ticks to `now` even if `previous` shows another thread swept in between... it then returns without sweeping, and ticks now = now (recent). Fine, next sweep will be interval from now. OK. But also: is Volatile.Read on long fine? Yes, Volatile.Read(ref long) exists. Is this too much? Alternative: don't throttle, sweep on every Set — O(n) per write, bad. Or use a Timer — adds Timer lifecycle complexity (dispose etc.). The throttled sweep is the right "simple" compromise. I'll keep it but with concise comments. Actually, maybe I simplify by using a lock instead: ```csharp private readonly object _cleanupLock = new(); private DateTimeOffset _lastCleanup; private void MaybeCleanup() { var now = DateTimeOffset.UtcNow; lock (_cleanupLock) { if (now - _lastCleanup < _cleanupInterval) return; _lastCleanup = now; } foreach (var kvp in _entries) if (kvp.Value.IsExpired) _entries.TryRemove(kvp.Key, out _); } ``` This is simpler to read. Lock contention only on writes every interval — negligible. I'll go with the lock version for readability. Hmm, but reading `_lastCleanup` happens inside the lock only — fine. Actually the lock version does a lock acquisition on EVERY Set. Cheap (uncontended lock ~20ns), fine for simple. I'll go with the lock version. Simplicity wins. Now GetOrAdd note: race may call factory multiple times. Mention in notes. Also add `GetOrCreate`? No, GetOrAdd is fine. Should Set of an expired key... Set just overwrites, fine. Do I include `#nullable enable`? If the user's project has nullable enabled, `out TValue? value` is right; if not, `?` on a generic type param is fine too actually (`TValue?` compiles as nullable annotation only when context enabled; otherwise... actually `TValue?` where TValue unconstrained: in nullable context it means "defaultable"; outside nullable context, `TValue?` gives warning CS8632 "annotation for nullable reference types should only be used within '#nullable' context"). To be safe, add `#nullable enable` at top of the file snippet. Good. Final code: ```csharp #nullable enable using System; using System.Collections.Concurrent; namespace Caching; ///

/// A simple thread-safe in-memory cache with sliding support via per-entry TTLs. /// Expired entries are evicted lazily on access, plus an opportunistic background-less sweep. ///

public sealed class SimpleCache where TKey : notnull { private sealed class CacheEntry { public CacheEntry(TValue value, DateTimeOffset expiresAt) { Value = value; ExpiresAt = expiresAt; } public TValue Value { get; } public DateTimeOffset ExpiresAt { get; } public bool IsExpired => DateTimeOffset.UtcNow >= ExpiresAt; } private readonly ConcurrentDictionary _entries = new(); private readonly TimeSpan _defaultTtl; private readonly TimeSpan _cleanupInterval; private readonly object _cleanupLock = new(); private DateTimeOffset _lastCleanup = DateTimeOffset.UtcNow; public SimpleCache(TimeSpan? defaultTtl = null, TimeSpan? cleanupInterval = null) { _defaultTtl = defaultTtl ?? TimeSpan.FromMinutes(5); _cleanupInterval = cleanupInterval ?? TimeSpan.FromMinutes(1); } public int Count => _entries.Count; public void Set(TKey key, TValue value, TimeSpan? ttl = null) { MaybeSweep(); _entries[key] = new CacheEntry(value, DateTimeOffset.UtcNow + (ttl ?? _defaultTtl)); } public bool TryGet(TKey key, out TValue? value) { MaybeSweep(); if (_entries.TryGetValue(key, out var entry) && !entry.IsExpired) { value = entry.Value; return true; } value = default; return false; } public TValue? Get(TKey key) => TryGet(key, out var value) ? value : default; public TValue GetOrAdd(TKey key, Func valueFactory, TimeSpan? ttl = null) { if (TryGet(key, out var existing) && existing is not null) return existing; var value = valueFactory(key); Set(key, value, ttl); return value; } public bool Remove(TKey key) => _entries.TryRemove(key, out _); public void Clear() => _entries.Clear(); private void MaybeSweep() { var now = DateTimeOffset.UtcNow; lock (_cleanupLock) { if (now - _lastCleanup < _cleanupInterval) return; _lastCleanup = now; } foreach (var kvp in _entries) { if (kvp.Value.IsExpired) _entries.TryRemove(kvp.Key, out _); } } } ``` Wait — GetOrAdd with value type TValue: `existing is not null` fails for structs (always true, and `existing` could be default(T) legitimately... but TryGet returned true means entry existed with non-expired, so value is whatever was stored, could be default for struct). For value types, `existing is not null` compiles? For unconstrained TValue, `existing` is type TValue?... hmm. With nullable annotations, `out TValue?` — when TValue is a struct, TValue? means Nullable? No — in nullable reference type context, `TValue?` for unconstrained generic means "TValue, possibly null" and boxes... Actually `TValue?` on an unconstrained generic parameter: the compiler treats it as TValue with nullable annotation. `existing is not null` — for a non-nullable struct value this check is always true (with a hint warning maybe). It compiles fine. And logic is correct: TryGet true → return existing. For structs, `is not null` is always true, fine. For reference types, if someone stored null value... edge case; TryGet true with null value → we'd recompute. Minor. Could restructure: ```csharp public TValue GetOrAdd(TKey key, Func valueFactory, TimeSpan? ttl = null) { if (TryGet(key, out var existing)) return existing!; // present and unexpired ... } ``` `return existing!;` — need null-forgiving since out param is TValue?. For struct TValue, existing is TValue (not null), `!` harmless. Cleaner. Use that. Hmm, one more subtlety: TryGet sets `value = default` when missing — for ref types null, structs default. Fine. Also: MaybeSweep in TryGet — calling lock on every read might be a bit much but it's cheap. Actually, hmm, every TryGet acquires a lock. Under heavy read load that's contention. Maybe only sweep on Set, not on TryGet? Reads then never clean — but lazy eviction in TryGet handles the read path (expired entries removed when... wait, my TryGet doesn't remove expired entry, it just ignores it). Let me have TryGet remove the expired entry it encounters: ```csharp public bool TryGet(TKey key, out TValue? value) { if (_entries.TryGetValue(key, out var entry)) { if (!entry.IsExpired) { value = entry.Value; return true; } // lazily evict expired entry _entries.TryRemove(key, out _); } value = default; return false; } ``` The TryRemove(key) race: between TryGetValue and TryRemove, another thread may Set a fresh value which we'd then remove. To guard, use the KeyValuePair overload (.NET 5+): ```csharp _entries.TryRemove(new KeyValuePair(key, entry)); ``` Hmm wait — the KVP overload: `public bool TryRemove(KeyValuePair item)` — it was added in .NET 5 (also exists as `ICollection.Remove`). Actually `ConcurrentDictionary` implements `ICollection>.Remove` since forever, and .NET 5 added a public `TryRemove(KeyValuePair)`. Using `((ICollection>)_entries).Remove(kvp)` works everywhere. For simplicity and modern .NET, use the public TryRemove(KVP). I'll note "on .NET 5+". Hmm, actually value equality: KVP Remove uses EqualityComparer.Default — CacheEntry is a sealed class without Equals override → reference equality. Since we hold the exact entry instance we read, this is precise. So sweep only on Set (writes), lazy evict on read. That removes lock from read path. Also maybe keep MaybeSweep call only in Set. Reads stay lock-free. One more consideration: `DateTimeOffset.UtcNow + ttl` — fine. Expiration semantics: absolute TTL per entry. Could add sliding expiration — skip, keep simple; mention as extension idea. Usage example: ```csharp var cache = new SimpleCache(defaultTtl: TimeSpan.FromMinutes(10)); cache.Set("greeting", "hello"); // uses default TTL cache.Set("token", "abc123", TimeSpan.FromSeconds(5)); // custom TTL if (cache.TryGet("greeting", out var greeting)) Console.WriteLine(greeting); // hello Console.WriteLine(cache.Get("missing") ?? "(not found)"); cache.GetOrAdd("expensive:42", k => $"computed-for-{k}"); // factory runs once (usually) Thread.Sleep(5_000); Console.WriteLine(cache.TryGet("token", out _)); // False — expired cache.Remove("greeting"); ``` Careful: `cache.Get("missing") ?? "(not found)"` — Get returns TValue? = string? null → `??` works for string. Fine. A compact demo with expiration: show TryGet false after sleep. Good. Notes section (short bullets): - Thread-safe: ConcurrentDictionary + lock only during periodic sweeps (once per cleanup interval on writes). - Lazy eviction: expired entries are dropped when read or during sweeps; Count may briefly include expired-but-unswept entries. - GetOrAdd may invoke the factory more than once under concurrent access (no per-key locking). Use Lazy wrapper if that matters. - For production, consider Microsoft.Extensions.Caching.Memory.IMemoryCache — this is a lightweight standalone alternative. Also mention .NET 5+ for the KVP TryRemove; provide fallback? Maybe a one-line comment in code: "// .NET 5+: removes only if it's still this exact entry". If on older frameworks, `((ICollection>)_entries).Remove(...)` — too noisy. Just note it in the bullets or code comment. Format check: The response should be mostly code. Intro one line. Code block for the class. Code block for usage. Bullet list of notes (4-5 bullets). No big headers needed, or maybe small bold labels like "Usage". Keep it tight. This is a coding task where markdown code blocks are essential. Length: moderate — the class is ~80 lines, usage ~15, notes 5 bullets. Reasonable. Let me write the final class carefully, checking compile-correctness mentally: ```csharp #nullable enable using System; using System.Collections.Concurrent; public sealed class SimpleCache where TKey : notnull { private sealed class CacheEntry { public CacheEntry(TValue value, DateTimeOffset expiresAt) { Value = value; ExpiresAt = expiresAt; } public TValue Value { get; } public DateTimeOffset ExpiresAt { get; } public bool IsExpired => DateTimeOffset.UtcNow >= ExpiresAt; } private readonly ConcurrentDictionary _entries = new(); private readonly TimeSpan _defaultTtl; private readonly TimeSpan _cleanupInterval; private readonly object _sweepLock = new(); private DateTimeOffset _lastSweep = DateTimeOffset.UtcNow; public SimpleCache(TimeSpan? defaultTtl = null, TimeSpan? cleanupInterval = null) { _defaultTtl = defaultTtl ?? TimeSpan.FromMinutes(5); _cleanupInterval = cleanupInterval ?? TimeSpan.FromMinutes(1); } ///

Number of entries currently stored (may include expired entries not yet swept).

public int Count => _entries.Count; public void Set(TKey key, TValue value, TimeSpan? ttl = null) { SweepIfDue(); var expiresAt = DateTimeOffset.UtcNow + (ttl ?? _defaultTtl); _entries[key] = new CacheEntry(value, expiresAt); } public bool TryGet(TKey key, out TValue? value) { if (_entries.TryGetValue(key, out var entry)) { if (!entry.IsExpired) { value = entry.Value; return true; } // Lazy eviction: remove it only if it's still the same entry (.NET 5+). _entries.TryRemove(new KeyValuePair(key, entry)); } value = default; return false; } public TValue? Get(TKey key) => TryGet(key, out var value) ? value : default; ///

Returns the cached value, or computes it with , caches it, and returns it.

public TValue GetOrAdd(TKey key, Func valueFactory, TimeSpan? ttl = null) { if (TryGet(key, out var existing)) return existing!; var value = valueFactory(key); Set(key, value, ttl); return value; } public bool Remove(TKey key) => _entries.TryRemove(key, out _); public void Clear() => _entries.Clear(); // Opportunistic cleanup: at most once per cleanup interval, piggybacked on writes. private void SweepIfDue() { var now = DateTimeOffset.UtcNow; lock (_sweepLock) { if (now - _lastSweep < _cleanupInterval) return; _lastSweep = now; } foreach (var kvp in _entries) { if (kvp.Value.IsExpired) _entries.TryRemove(kvp.Key, out _); } } } ``` Check `TryGet` out param: `out TValue? value` — with unconstrained TValue and nullable enabled this is fine. `value = default;` fine. `Get`: returns `TValue?`, and `TryGet(...) ? value : default` — type is TValue?... expression type: `value` is TValue?, `default` is... For unconstrained generic, default literal → TValue? — ok returns TValue? which matches declared TValue?. Fine. Consumers use `??` or null checks. GetOrAdd: `if (TryGet(key, out var existing)) return existing!;` — `!` on TValue? → TValue. Compiles. Note factory runs outside any lock. There's also a possible race where factory's Set overwrites a concurrent Set — last wins, fine. Note: `where TKey : notnull` — ConcurrentDictionary requires... actually it doesn't have the constraint; but prevents null keys. Keep it. It's supported since C# 8. One question: does `new KeyValuePair(key, entry)` TryRemove exist? In .NET 5+, `ConcurrentDictionary.TryRemove(KeyValuePair)` — yes, public API added in .NET 5. For .NET Core 3.1/ Framework, can cast to ICollection. I'll mention in a comment or bullet. Add code comment "// .NET 5+ — removes only if unchanged; on older TFMs use ((ICollection>)_entries).Remove(...)" — maybe too long; put in bullets instead. Brief inline comment + bullet. Also note that Get/GetOrAdd for value types: `Get` returns default(TValue) when missing, which is indistinguishable from a stored default. Recommend TryGet for structs. Add a bullet? Maybe one line. Usage snippet — make it runnable as a top-level program: ```csharp var cache = new SimpleCache(defaultTtl: TimeSpan.FromMinutes(10)); cache.Set("greeting", "hello"); // default TTL cache.Set("token", "abc123", TimeSpan.FromSeconds(2)); // custom TTL if (cache.TryGet("greeting", out var greeting)) Console.WriteLine(greeting); // hello Console.WriteLine(cache.Get("missing") ?? "(not found)"); // (not found) var config = cache.GetOrAdd("config", key => $"value-for-{key}"); Console.WriteLine(cache.TryGet("token", out _)); // True Thread.Sleep(TimeSpan.FromSeconds(2)); Console.WriteLine(cache.TryGet("token", out _)); // False (expired) ``` Good demo. Bullets: - **Thread-safe** — storage is a `ConcurrentDictionary`; the sweep lock is only taken during the (at most once-per-interval) cleanup, not on reads. - **Expiry is lazy** — expired items are dropped on read and by the opportunistic sweep on writes, so no background timer/thread is needed. `Count` may include expired entries briefly. - **GetOrAdd isn't atomic** — under concurrent first-access the factory may run more than once (last write wins). Wrap values in `Lazy` if the factory is expensive or non-idempotent. - The `TryRemove(KeyValuePair<,>)` overload used for lazy eviction requires .NET 5+; on older targets replace with `((ICollection>)_entries).Remove(...)`. - For production apps, `Microsoft.Extensions.Caching.Memory` (`IMemoryCache`) offers more (sliding expiration, size limits, eviction callbacks) — this is a dependency-free alternative. Also mention possible extensions: sliding expiration, capacity/LRU. Maybe one bullet or skip. Keep to ~5 bullets. I think that's a solid answer. Write it now. Brief intro: "Here's a thread-safe, generic cache with per-entry TTL expiration..." Here's a thread-safe, dependency-free cache with per-entry TTL expiration. Expired entries are evicted lazily (on read) plus an opportunistic sweep on writes — no background timer needed. ```csharp #nullable enable using System; using System.Collections.Concurrent; public sealed class SimpleCache where TKey : notnull { private sealed class CacheEntry { public CacheEntry(TValue value, DateTimeOffset expiresAt) { Value = value; ExpiresAt = expiresAt; } public TValue Value { get; } public DateTimeOffset ExpiresAt { get; } public bool IsExpired => DateTimeOffset.UtcNow >= ExpiresAt; } private readonly ConcurrentDictionary _entries = new(); private readonly TimeSpan _defaultTtl; private readonly TimeSpan _cleanupInterval; private readonly object _sweepLock = new(); private DateTimeOffset _lastSweep = DateTimeOffset.UtcNow; public SimpleCache(TimeSpan? defaultTtl = null, TimeSpan? cleanupInterval = null) { _defaultTtl = defaultTtl ?? TimeSpan.FromMinutes(5); _cleanupInterval = cleanupInterval ?? TimeSpan.FromMinutes(1); } ///

Entries currently stored (may briefly include expired, not-yet-swept items).

public int Count => _entries.Count; public void Set(TKey key, TValue value, TimeSpan? ttl = null) { SweepIfDue(); _entries[key] = new CacheEntry(value, DateTimeOffset.UtcNow + (ttl ?? _defaultTtl)); } public bool TryGet(TKey key, out TValue? value) { if (_entries.TryGetValue(key, out var entry)) { if (!entry.IsExpired) { value = entry.Value; return true; } // Lazy eviction: remove only if it's still this exact entry (needs .NET 5+). _entries.TryRemove(new KeyValuePair(key, entry)); } value = default; return false; } public TValue? Get(TKey key) => TryGet(key, out var value) ? value : default; ///

Returns the cached value, or computes it via the factory, caches it, and returns it.

C# cache Container