缓存类和修改的集合

Question

我编写了一个通用 Cache 类，旨在返回一个内存中的对象，并且只偶尔评估 src（一个 IQueryable 或返回 IQueryable 的函数）。它在我的应用程序中的几个地方使用，通过实体框架获取大量数据非常昂贵。

这叫

    //class level
    private static CachedData<Foo> fooCache= new CachedData<Foo>(); 

    //method level
    var results = fooCache.GetData("foos", fooRepo.Include("Bars"));

虽然它在测试中似乎工作正常，但在繁忙的 Web 服务器上运行时，我看到“集合已修改；枚举操作可能无法执行”的一些问题。使用结果的代码中的错误。

这一定是因为一个线程在锁内覆盖结果对象，而另一个线程在锁外使用它们。

我猜我唯一的解决方案是将结果的副本而不是原始结果返回给每个消费者，并且我不能允许副本在 Fetch 锁内发生，但可以同时发生多个副本。

任何人都可以提出更好的方法，或者帮助锁定策略吗？

public class CachedData<T> where T:class 
{
    private static Dictionary<string, IEnumerable<T>> DataCache { get; set; } 
    public  static Dictionary<string, DateTime> Expire { get; set; }
    public int TTL { get; set; }
    private object lo = new object();

    public CachedData()
    {
        TTL = 600;
        Expire = new Dictionary<string, DateTime>();
        DataCache = new Dictionary<string, IEnumerable<T>>();
    }

    public IEnumerable<T> GetData(string key, Func<IQueryable<T>> src)
    {
        var bc = brandKey(key);
        if (!DataCache.ContainsKey(bc)) Fetch(bc, src);
        if (DateTime.Now > Expire[bc]) Fetch(bc, src);
        return DataCache[bc];
    }


    public IEnumerable<T> GetData(string key, IQueryable<T> src)
    {
        var bc = brandKey(key);
        if ((!DataCache.ContainsKey(bc)) || (DateTime.Now > Expire[bc])) Fetch(bc, src);
        return DataCache[bc];
    }

    private void Fetch(string key, IQueryable<T> src )
    {
        lock (lo)
        {
            if ((!DataCache.ContainsKey(key)) || (DateTime.Now > Expire[key])) ExecuteFetch(key, src);
        }
    }

    private void Fetch(string key, Func<IQueryable<T>> src)
    {
        lock (lo)
        {
            if ((!DataCache.ContainsKey(key)) || (DateTime.Now > Expire[key])) ExecuteFetch(key, src());
        }
    }

    private void ExecuteFetch(string key, IQueryable<T> src)
    {
        if (!DataCache.ContainsKey(key)) DataCache.Add(key, src.ToList());
        else DataCache[key] = src.ToList();
        if (!Expire.ContainsKey(key)) Expire.Add(key, DateTime.Now.AddSeconds(TTL));
        else Expire[key] = DateTime.Now.AddSeconds(TTL);
    }


    private string brandKey(string key, int? brandid = null)
    {
        return string.Format("{0}/{1}", brandid ?? Config.BrandID, key);
    }
 }

Answer 1

我通常使用ConcurrentDictionary<TKey, Lazy<TValue>>。这为您提供了每把钥匙的锁。它使在获取时保持锁定的策略可行。这也避免了缓存标记。它保证每个密钥只会发生一次评估。 Lazy<T> 完全自动锁定。

关于你的过期逻辑：你可以设置一个定时器，每 X 秒清理一次字典（或完全重写它）。