我陷入了一个场景。 我的代码如下：

更新：它不是关于如何使用数据缓存，我已经在使用它及其工作，它是关于扩展它，以便该方法在到期时间和从外部源获取新数据之间不会进行调用

object = (string)this.GetDataFromCache(cache, cacheKey);

if(String.IsNullOrEmpty(object))
{
  // get the data. It takes 100ms
  SetDataIntoCache(cache, cacheKey, object, DateTime.Now.AddMilliseconds(500));
}

因此，如果项目过期，用户会调用缓存并从中获取数据，并从服务中获取数据并保存以防万一，t问题是，每当有待处理的请求（请求正在进行）时，服务就会发送另一个请求，因为对象已过期。最终，每秒最多应有 2-3 个调用，并且每秒对外部服务有 10-20 个调用。

除了使用数组和时间戳等创建自己的自定义类之外，是否有任何最佳方法可以做到这一点，这样请求时间之间就不会发生冲突？

顺便说一句，缓存的保存代码是-

private void SetDataIntoCache(ObjectCache cacheStore, string cacheKey, object target, DateTime slidingExpirationDuration)
{
  CacheItemPolicy cacheItemPolicy = new CacheItemPolicy();

  cacheItemPolicy.AbsoluteExpiration = slidingExpirationDuration;
  cacheStore.Add(cacheKey, target, cacheItemPolicy);
}

我已经改编了解决方案.NET 中的微缓存 http://www.superstarcoders.com/blogs/posts/micro-caching-in-asp-net.aspx与使用System.Runtime.Caching.ObjectCache for Mvc站点地图提供者 https://github.com/maartenba/mvcsitemapprovider。完整的实施有一个ICacheProvider允许之间交换的接口System.Runtime.Caching and System.Web.Caching，但这是一个精简版本，应该可以满足您的需求。

该模式最引人注目的特性是，它使用轻量级版本的惰性锁来确保在缓存过期后仅从数据源加载数据 1 次，无论有多少并发线程尝试加载数据。

using System;
using System.Runtime.Caching;
using System.Threading;

public interface IMicroCache<T>
{
    bool Contains(string key);
    T GetOrAdd(string key, Func<T> loadFunction, Func<CacheItemPolicy> getCacheItemPolicyFunction);
    void Remove(string key);
}

public class MicroCache<T> : IMicroCache<T>
{
    public MicroCache(ObjectCache objectCache)
    {
        if (objectCache == null)
            throw new ArgumentNullException("objectCache");

        this.cache = objectCache;
    }
    private readonly ObjectCache cache;
    private ReaderWriterLockSlim synclock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);

    public bool Contains(string key)
    {
        synclock.EnterReadLock();
        try
        {
            return this.cache.Contains(key);
        }
        finally
        {
            synclock.ExitReadLock();
        }
    }

    public T GetOrAdd(string key, Func<T> loadFunction, Func<CacheItemPolicy> getCacheItemPolicyFunction)
    {
        LazyLock<T> lazy;
        bool success;

        synclock.EnterReadLock();
        try
        {
            success = this.TryGetValue(key, out lazy);
        }
        finally
        {
            synclock.ExitReadLock();
        }

        if (!success)
        {
            synclock.EnterWriteLock();
            try
            {
                if (!this.TryGetValue(key, out lazy))
                {
                    lazy = new LazyLock<T>();
                    var policy = getCacheItemPolicyFunction();
                    this.cache.Add(key, lazy, policy);
                }
            }
            finally
            {
                synclock.ExitWriteLock();
            }
        }

        return lazy.Get(loadFunction);
    }

    public void Remove(string key)
    {
        synclock.EnterWriteLock();
        try
        {
            this.cache.Remove(key);
        }
        finally
        {
            synclock.ExitWriteLock();
        }
    }


    private bool TryGetValue(string key, out LazyLock<T> value)
    {
        value = (LazyLock<T>)this.cache.Get(key);
        if (value != null)
        {
            return true;
        }
        return false;
    }

    private sealed class LazyLock<T>
    {
        private volatile bool got;
        private T value;

        public T Get(Func<T> activator)
        {
            if (!got)
            {
                if (activator == null)
                {
                    return default(T);
                }

                lock (this)
                {
                    if (!got)
                    {
                        value = activator();

                        got = true;
                    }
                }
            }

            return value;
        }
    }
}

Usage

// Load the cache as a static singleton so all of the threads
// use the same instance.
private static IMicroCache<string> stringCache = 
    new MicroCache<string>(System.Runtime.Caching.MemoryCache.Default);

public string GetData(string key)
{
    return stringCache.GetOrAdd(
        key,
        () => LoadData(key),
        () => LoadCacheItemPolicy(key));
}

private string LoadData(string key)
{
    // Load data from persistent source here

    return "some loaded string";
}

private CacheItemPolicy LoadCacheItemPolicy(string key)
{
    var policy = new CacheItemPolicy();

    // This ensures the cache will survive application
    // pool restarts in ASP.NET/MVC
    policy.Priority = CacheItemPriority.NotRemovable;

    policy.AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(1);

    // Load Dependencies
    // policy.ChangeMonitors.Add(new HostFileChangeMonitor(new string[] { fileName }));

    return policy;
}

NOTE:正如前面提到的，如果将需要 100 毫秒才能检索的值缓存为 500 毫秒，您可能不会获得任何好处。您很可能应该选择更长的时间段来将项目保留在缓存中。数据源中的项目真的如此不稳定，以至于可以如此快速地更改吗？如果是这样，也许你应该考虑使用ChangeMonitor使任何过时的数据无效，这样您就不会花费太多的 CPU 时间来加载缓存。然后您可以将缓存时间更改为分钟而不是毫秒。