C# 如何实现定期缓存重新加载 公共类缓存：ICache { 私有只读IDictionary\u内部缓存； 私有只读对象_syncLock=新对象（）； 公共缓存（） { _internalCache=新字典（）； } 公共TValue此[TKey] { 得到 { 锁（同步锁）{ //... } } 设置 { 锁（同步锁）{ //... } } } 公共ICollection GetAll（） { 锁（同步锁）{ 返回_internalCache.Values； } } 公共bool ContainsKey（TKey） { 锁（同步锁） { 返回_internalCache.ContainsKey（键）； } } }

上面的缓存由单例包装器使用。以下是实现

public class Cache<TKey, TValue> : ICache<TKey, TValue>
{
    private readonly IDictionary<TKey, TValue> _internalCache;
    private readonly object _syncLock = new object();

    public Cache()
    {
        _internalCache = new Dictionary<TKey, TValue>();
    }

    public TValue this[TKey key]
    {
        get
        {
            lock (_syncLock) {
               //...
            }
        }
        set
        {
            lock (_syncLock) {
               //...
            }
        }
    }

    public ICollection<TValue> GetAll()
    {
        lock (_syncLock) {
            return _internalCache.Values;
        }
    }

    public bool ContainsKey(TKey key)
    {
        lock (_syncLock)
        {
            return _internalCache.ContainsKey(key);
        }
    }

}  

公共类活动缓存：ICache
{
私有只读ICache_cache=new cache（）；
私有静态只读ActivityCache _实例=新ActivityCache（）；
// http://www.yoda.arachsys.com/csharp/singleton.html
静态活动缓存（）
{
}
ActivityCache（）
{
}
公共静态ActivityCache实例
{
获取{return\u instance；}
}
公共活动此[字符串活动URL]
{
得到
{
if（string.IsNullOrEmpty（activityUrl））
{
返回null；
}
返回_缓存[activityUrl]；
}
设置
{
if（string.IsNullOrEmpty（activityUrl））
{
返回；
}
_缓存[activityUrl]=值；
}
}
公共ICollection GetAll（）
{
返回_cache.GetAll（）；
}
公共bool ContainsKey（字符串键）
{
返回_cache.ContainsKey（键）；
}
}

现在我的问题是，如果我想重新加载缓存，我可以使用以下方法吗？我想使重新加载无缝，这样就可以让线程访问过时的信息

public class ActivityCache : ICache<string, Activity> 
 {
    private readonly ICache<string, Activity> _cache = new Cache<string, Activity>();

    private static readonly ActivityCache _instance = new ActivityCache();

    // http://www.yoda.arachsys.com/csharp/singleton.html
    static ActivityCache()
    {
    }

    ActivityCache()
    {
    }

    public static ActivityCache Instance
    {
        get { return _instance; }
    }

    public Activity this[string activityUrl]
    {
        get
        {
            if (string.IsNullOrEmpty(activityUrl))
            {
                return null;
            }

            return _cache[activityUrl];
        }
        set
        {
            if (string.IsNullOrEmpty(activityUrl))
            {
                return;
            }

            _cache[activityUrl] = value;
        }
    }

    public ICollection<Activity> GetAll()
    {
        return _cache.GetAll();
    }

    public bool ContainsKey(string key)
    {
        return _cache.ContainsKey(key);
    }
}

public void重载（IDictionary值）
{
cache=newdictionary（）；
foreach（值中的KeyValuePair值）
{
cache[value.Key]=value.value；
}
锁（同步锁）
{
_internalCache=cache；
}
}

---

_internalCache是只读的。它不允许我更改作业。

事实上，您不需要重新创建字典（因为它是只读的）。您可以清除所有值，只需从

IDictionary

调用

clear（）

方法。对于示例：

public void Reload(IDictionary<TKey, TValue> values)
{
    cache = new Dictionary<TKey, TValue> ();
    foreach (KeyValuePair<TKey, TValue> value in values)
    {
        cache[value.Key] = value.Value;
    }

    lock (_syncLock)
    {
        _internalCache = cache;
    }
}

public void重载（IDictionary值）
{
锁（同步锁）
{
_internalCache.Clear（）；
foreach（值中的var值）
_internalCache.Add（value）；
}
}

内部缓存的

\u

是只读的（我假设您不只是想删除

readonly

关键字以使事情正常工作）。但这只会影响对列表的引用。您仍然可以替换列表中的项目，如下所示：

public void Reload(IDictionary<TKey, TValue> values)
{
    lock (_synclock)
    {
       _internalCache.Clear();

       foreach (var value in values)
          _internalCache.Add(value);
    }
}

public void重载（IDictionary值）
{
锁（同步锁）
{
_internalCache.Clear（）；
_internalCache.AddRange（值）；
}
}

---

也可以，而不是自己编写所有的锁，也许你可以考虑使用一个安全的方式访问密钥的方法，甚至允许你提供一个委托，以便在缺少密钥时重新填充条目。

认为在某处你需要一个<代码>锁<代码>。是的，它可以更好。谢谢@JohnWuthanks，但我只想在创建新缓存后处理旧缓存，以便无缝更改状态。通过在填充之前清除缓存，前台线程可能会丢失缓存。我可以提供陈旧的数据。所以我尝试了这种方法。

public void Reload(IDictionary<TKey, TValue> values)
{
    lock(_synclock)
    {
        _internalCache.Clear();
        _internalCache.AddRange(values);
    }
}