为什么不能直接 await 一个 MemoryCache.GetOrCreateAsync
因为
MemoryCache原生不提供真正的异步 API。它的
GetOrCreateAsync方法只是同步执行缓存逻辑后返回
Task.FromResult，底层仍是阻塞式调用。如果你在回调里写了
await HttpClient.GetAsync(...)，整个缓存委托会阻塞线程，违背异步初衷。
用 SemaphoreSlim 控制并发，避免缓存击穿
多个请求同时发现缓存缺失时，应只让一个去加载数据，其余等待结果。直接用
lock会阻塞线程，改用
SemaphoreSlim实现异步等待：
private static readonly ConcurrentDictionary<string, SemaphoreSlim> _semaphores = new();
private static readonly MemoryCache _cache = new(new MemoryCacheOptions());
public async Task<T> GetOrLoadAsync<T>(string key, Func<CancellationToken, Task<T>> factory, TimeSpan? expiration = null)
{
var cacheEntry = _cache.Get<Task<T>>(key);
if (cacheEntry != null) return await cacheEntry;
var semaphore = _semaphores.GetOrAdd(key, _ => new SemaphoreSlim(1, 1));
try
{
await semaphore.WaitAsync();
cacheEntry = _cache.Get<Task<T>>(key);
if (cacheEntry != null) return await cacheEntry;
var task = factory(default).AsTask(); // 或直接 factory(CancellationToken.None)
_cache.Set(key, task, expiration ?? TimeSpan.FromMinutes(10));
return await task;
}
finally
{
semaphore.Release();
if (semaphore.CurrentCount == 0) _semaphores.TryRemove(key, out _);
}
}
注意缓存项的生命周期和异常传播
Task对象本身可被缓存，但需留意：如果工厂方法抛出异常，该异常会被包裹进
Task并缓存——后续调用
await会再次抛出。这通常不是期望行为： 可在
factory内部捕获异常，返回默认值或空结果 或使用
TryGet+
Task.WhenAny配合超时控制 避免把
Task<t></t>当作“值”缓存后又反复
await——它不会重放，但异常状态会持续存在
替代方案：用 Lazy> 简化逻辑
若不需要过期策略，
ConcurrentDictionary+
Lazy<task>></task>更轻量：
private static readonly ConcurrentDictionary<string, Lazy<Task<string>>> _lazyCache = new();
public Task<string> GetOrLoadLazy(string key, Func<Task<string>> factory)
=> _lazyCache.GetOrAdd(key, _ => new Lazy<Task<string>>(factory)).Value;
它天然保证只执行一次工厂函数，且支持异步；缺点是无法主动过期或内存回收，适合短生命周期或低更新频率场景。
真正难处理的是缓存过期 + 异步加载 + 并发安全三者叠加。多数人忽略的是：缓存项不该是T，而应是
Task<t></t>，且必须确保这个
Task不被多次触发或错误重用。
