标签: memorycache

此性能测试是错误的还是系统缓存正在以卓越的性能运行？

这是我的结果:
[13]交互次数100000:63毫秒
[14]交互次数100000:139毫秒
[12]交互次数100000:47毫秒
[15]交互次数100000:44毫秒
测试结束.

硬件:x86 Family 6 Model 23 Stepping GenuineIntel~2992 Mhz 3.327 MB,5.1.2600 Service Pack 3

using System;
using System.Collections.Generic;
using System.Runtime.Caching;
using System.Diagnostics;
using System.Threading;

namespace CacheNet40
{
    public class CacheTest
    {
        private ObjectCache cache;

        public CacheTest()
        {
            cache = MemoryCache.Default;
        }

        public void AddItem(CacheItem item, double span)
        {
            CacheItemPolicy cp = new CacheItemPolicy();
            cp.SlidingExpiration.Add(TimeSpan.FromMinutes(span));

            cache.Add(item, cp);
        }
        public Object GetItem(string key)
        {
            return cache.Get(key);
        }
    }

    class Program
    {        
        private static CacheTest Cache = …

我试图在对其依赖的其他条目进行更改时从MemoryCache中逐出条目.这是通过为依赖键的依赖项创建缓存条目更改监视器来设置的:

public bool AddToCache(string key, object dataItem, 
    DateTimeOffset absoluteExpiration, IEnumerable<string> dependencyKeys)
{
    bool result = false;

    if (!string.IsNullOrWhiteSpace(key) && dataItem != null)
    {
        CacheItemPolicy policy = new CacheItemPolicy {
            AbsoluteExpiration = absoluteExpiration
        };

        if (masterKeys != null && masterKeys.Any())
        {
            policy.ChangeMonitors.Add(
                this.provider.Cache.
                    CreateCacheEntryChangeMonitor(dependencyKeys));

            foreach (ChangeMonitor monitor in policy.ChangeMonitors)
            {
                monitor.NotifyOnChanged(this.OnDependencyChanged);
            }
        }

        result = this.provider.Cache.Add(key, dataItem, policy);
    }

    return result;
}

该OnChangedCallBack方法是这样的:

private void OnDependencyChanged(object state)
{
    // what do I do here as "state" is always null? …

我正在尝试创建与第三方API的连接池,并且如果它们未被使用,则连接在一段时间后到期.当它们过期时,需要通过第三方API断开连接.

似乎MemoryCache(System.Runtime.Caching)会处理这个问题.不过,UpdateCallback似乎表现得很奇怪.

一个简单的LINQPad示例:

void Main()
{
    var cache = MemoryCache.Default;
    var policy = new CacheItemPolicy();
    policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(1);
    policy.UpdateCallback = Update;
    cache.Set("figkey", "fig", policy);

    Thread.Sleep(2000);

    object result = cache.Get("figkey");

    Console.WriteLine(result == null ? "null" : result);
}

public static void Update(CacheEntryUpdateArguments arguments)
{
    Console.WriteLine("got here");
}

如果我运行它,输出是:

fig

它不输出"来到这里".

如果我注释掉以该行开头的行policy.UpdateCallback,则输出为:

null

我究竟做错了什么？

如果有更好的方法来完成我的任务,我愿意接受其他建议.

我正在使用 .NET 4 的 System.Runtime.Caching 中的 MemoryCache，我希望在目录更改时使缓存条目无效。

HostFileChangeMonitor 应该处理文件和目录，所以我像这样添加它：

var cacheItemPolicy = new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(30) };
cacheItemPolicy.ChangeMonitors.Add(new HostFileChangeMonitor(new List<string> { folder }));

但后来我得到一个例外：

System.ArgumentOutOfRangeException: The UTC time represented when the offset is applied must be between year 0 and 10,000.

仅当我在 ASP.NET 网站中使用代码时才会发生这种情况。它在控制台应用程序内部工作正常。

我在 ms connect 上发现了这个，但是我添加到 HostFileChangeMonitor 的目录存在。

谢谢你的帮助。

从MemoryCache实例中删除大量项目的推荐方法是什么？

基于围绕这个问题的讨论,似乎首选方法是为整个应用程序使用单个缓存,并使用命名空间的密钥,以允许在同一实例中缓存多个逻辑类型的项.

但是,使用单个缓存实例会导致从缓存中过期(删除)大量项目的问题.特别是在某种逻辑类型的所有项目必须过期的情况下.

目前我找到的唯一解决方案是基于这个问题的答案,但是从性能观点来看,它实际上并不是很好,因为你必须枚举缓存中的所有键,并测试命名空间,这可能是相当的耗时的!

我现在提出的唯一解决方法是使用版本号为缓存中的所有对象创建一个瘦包装器,每当访问一个对象时,如果缓存版本与当前版本不匹配,则丢弃它.因此,每当我需要清除某种类型的所有项目时,我都会提高当前版本号,使所有缓存项无效.

上面的解决方案看起来非常可靠.但我不禁想知道是否有更直接的方法来实现同样的目标？

这是我目前的实施:

private class MemCacheWrapper<TItemType> 
              where TItemType : class
{            
  private int _version;
  private Guid _guid;
  private System.Runtime.Caching.ObjectCache _cache;

  private class ThinWrapper
  {
     public ThinWrapper(TItemType item, int version)
     {
        Item = item;
        Version = version;
     }

     public TItemType Item { get; set; }
     public int Version { get; set; }
  }

  public MemCacheWrapper()
  {
      _cache = System.Runtime.Caching.MemoryCache.Default;
      _version = 0;
      _guid = Guid.NewGuid();
  }

  public TItemType Get(int …

我的 asp.net mvc 3 应用程序中有一个控制器操作。

我的操作包括数据库获取操作并将结果输出到视图中。我可以使用 OutputCache 操作过滤器属性将操作结果存储到缓存中。我还可以使用 MemoryCache 类来存储数据库获取操作的数据。它们都会显示缓存中的数据。OutputCache会将整个结果存储到缓存中。MemoryCache 类会将数据库获取结果存储到缓存中，并且该操作将从缓存中获取数据，而不是对相同结果发出新的数据库请求。

我的问题是申请哪一个更好？我有一种感觉，OutputCache 操作过滤器属性会很好地工作，因为它将数据库获取结果和操作结果都存储到缓存中。

将缓存条目添加到 System.Runtime.Caching.MemoryCache 时，可以使用 AbsoluteExpiration 指定 CacheItemPolicy。根据文档（https://msdn.microsoft.com/en-us/library/Dd780607(v=VS.110,d=hv.2).aspx），AbsoluteExpiration是“在缓存条目被逐出”。

是的，这就是我想要的 - 指定我的缓存条目将过期的“时间段”。但 AbsoluteExpiration 的类型为 DateTimeOffset 而不是 TimeSpan，因此它是“时间点”而不是“时间段”。那我该怎么设置呢？例如，如果我希望条目在 60 秒内过期，我应该将 AbsoluteExpiration 设置为 吗DateTimeOffset.UtcNow.AddSeconds(60)？如果我设置为 ，我会得到相同的结果吗DateTimeOffset.Now.AddSeconds(60)？有什么理由使用其中之一？

我正在使用LazyCache ，并且希望每小时刷新一次缓存，但理想情况下，我希望缓存项过期后的第一个调用者不要等待缓存重新加载。我写了以下内容

public async Task<List<KeyValuePair<string, string>>> GetCarriersAsync()\n{\n\n    var options = new MemoryCacheEntryOptions\n    {\n        AbsoluteExpirationRelativeToNow = new TimeSpan(1,0,0),// consider to config\n    }.RegisterPostEvictionCallback(\n         async  (key, value, reason, state) =>\n        {\n            await GetCarriersAsync();//will save to cache\n            _logger.LogInformation("Carriers are reloaded: " );\n        });\n    Func<Task<List<KeyValuePair<string, string>>>> cacheableAsyncFunc = () => GetCarriersFromApi();\n    var cachedCarriers = await _cache.GetOrAddAsync($"Carriers", cacheableAsyncFunc, options);\n\n    return cachedCarriers;\n}\n

但是，当缓存项过期时，不会调用 RegisterPostEvictionCallback，而是仅在对该项的下一个请求发生时调用（并且调用者需要等待漫长的操作）。

线程 Expiration 几乎永远不会在后台自行发生\xc2\xa0#248解释说这是设计使然，并建议解决方法来指定 CancellationTokenSource.CancelAfter(TimeSpan.FromHours(1)) 而不是 SetAbsoluteExpiration。

不幸的是，LazyCache.GetOrAddAsync 没有\xe2\x80\x99t 有 CancellationToken 作为参数。\n在预定时间触发缓存重新加载且第一个用户的等待时间最短的最佳方法是什么？

我正在尝试将.Net框架应用程序迁移到.Net Core，在此过程中，我想将内存中的缓存从System.Runtime.Caching/MemoryCache迁移到Microsoft.Extensions.Caching.Memory/IMemoryCache。但是我有一个问题IMemoryCache，在删除/撤消缓存之前，我找不到刷新缓存的方法。

在的情况下System.Runtime.Caching/MemoryCache，可以UpdateCallback在CacheItemPolicy其中设置回调函数的委托的属性，并且在逐出缓存对象之前，将在单独的线程中调用此函数。即使回调函数需要很长时间来获取新数据，MemoryCache仍将在过期之前继续提供旧数据，这确保了我的代码在缓存刷新过程中无需等待数据。

但是我没有看到这样的功能，在Microsoft.Extensions.Caching.Memory/IMemoryCache里面有 RegisterPostEvictionCallback属性和PostEvictionCallbacks扩展方法MemoryCacheEntryOptions。但是这两个都将在从缓存中逐出缓存条目后触发。因此，如果此回调花费较长时间，则需要等待所有获取此数据的请求。

有什么解决办法吗？

我有2个或更多属性唯一的模型。例如，该类的对象在Entity名称和ID上都是唯一的。

public class Entity
{
    public int Id { get; set; }
    public string Name { get; set; }
}

我有一个模型存储库：

public class EntityRepository
{
    ...
    public Entity GetById(int id)
    {
        return db.GetById(id);
    }
    public Entity GetByName(string name)
    {
        return db.GetByName(name);
    }
}

什么是缓存到两个呼叫的最佳方式GetById，并呼吁GetByName使用Microsoft.Extensions.Caching.Memory.IMemoryCache？

当前解决方案：

public class EntityRepository
{
    ...
    public Entity GetById(int id)
    {
        return Cache.GetOrCreate($"id:{id}", cacheEntry =>
        {
            return db.GetById(id);
        });
    }
    public Entity GetByName(string name)
    {
        return Cache.GetOrCreate($"name:{name}", cacheEntry …