我已经阅读了大量关于 MVC 应用程序中的页面缓存和部分页面缓存的信息。不过，我想知道您将如何缓存数据。
在我的场景中，我将使用 LINQ to Entities（实体框架）。在第一次调用 GetNames（或任何方法）时，我想从数据库中获取数据。我想将结果保存在缓存中，并在第二次调用时使用缓存版本（如果存在）。
谁能举例说明这将如何工作，应该在哪里实施（模型？）以及是否可行。
我已经在传统的 ASP.NET 应用程序中看到过这种情况，通常用于非常静态的数据。
【问题讨论】：
标签： asp.net-mvc database caching
这是我使用的一个不错且简单的缓存助手类/服务：
using System.Runtime.Caching;
public class InMemoryCache: ICacheService
{
public T GetOrSet<T>(string cacheKey, Func<T> getItemCallback) where T : class
{
T item = MemoryCache.Default.Get(cacheKey) as T;
if (item == null)
{
item = getItemCallback();
MemoryCache.Default.Add(cacheKey, item, DateTime.Now.AddMinutes(10));
}
return item;
}
}
interface ICacheService
{
T GetOrSet<T>(string cacheKey, Func<T> getItemCallback) where T : class;
}
cacheProvider.GetOrSet("cache key", (delegate method if cache is empty));
缓存提供者会检查缓存中是否有名为“cache id”的内容，如果没有，它将调用委托方法来获取数据并将其存储在缓存中。
var products=cacheService.GetOrSet("catalog.products", ()=>productRepository.GetAll())
【讨论】：
在您的模型中引用System.Web dll 并使用System.Web.Caching.Cache
public string[] GetNames()
{
string[] names = Cache["names"] as string[];
if(names == null) //not in cache
{
names = DB.GetNames();
Cache["names"] = names;
}
return names;
}
有点简化，但我想这会奏效。这不是 MVC 特定的，我一直使用这种方法来缓存数据。
【讨论】：
DB.GetNames().AsQueryable 方法？
我指的是TT的帖子并建议以下方法：
在您的模型中引用 System.Web dll 并使用 System.Web.Caching.Cache
public string[] GetNames()
{
var noms = Cache["names"];
if(noms == null)
{
noms = DB.GetNames();
Cache["names"] = noms;
}
return ((string[])noms);
}
您不应该返回从缓存中重新读取的值，因为您永远不会知道在那个特定时刻它是否仍在缓存中。即使您之前在语句中插入了它，它也可能已经消失或从未添加到缓存中 - 您只是不知道。
所以你添加从数据库读取的数据并直接返回，而不是从缓存中重新读取。
【讨论】：
Cache["names"] = noms;这行不是放入缓存了吗？
对于 .NET 4.5+ 框架
添加参考：System.Runtime.Caching
添加 using 语句：
using System.Runtime.Caching;
public string[] GetNames()
{
var noms = System.Runtime.Caching.MemoryCache.Default["names"];
if(noms == null)
{
noms = DB.GetNames();
System.Runtime.Caching.MemoryCache.Default["names"] = noms;
}
return ((string[])noms);
}
在 .NET Framework 3.5 及更早版本中，ASP.NET 在 System.Web.Caching 命名空间中提供了内存缓存实现。在早期版本的 .NET Framework 中，缓存仅在 System.Web 命名空间中可用，因此需要依赖于 ASP.NET 类。在 .NET Framework 4 中，System.Runtime.Caching 命名空间包含为 Web 和非 Web 应用程序设计的 API。
更多信息：
【讨论】：
Db.GerNames() 来自哪里？
Steve Smith 写了两篇很棒的博客文章，展示了如何在 ASP.NET MVC 中使用他的 CachedRepository 模式。它有效地使用了存储库模式，让您无需更改现有代码即可获得缓存。
http://ardalis.com/Introducing-the-CachedRepository-Pattern
http://ardalis.com/building-a-cachedrepository-via-strategy-pattern
在这两篇文章中，他向您展示了如何设置此模式，并解释了它为何有用。通过使用这种模式，您可以获得缓存，而您现有的代码不会看到任何缓存逻辑。本质上，您使用缓存的存储库就像使用其他存储库一样。
【讨论】：
我以这种方式使用它，它对我有用。 https://msdn.microsoft.com/en-us/library/system.web.caching.cache.add(v=vs.110).aspx system.web.caching.cache.add 的参数信息。
public string GetInfo()
{
string name = string.Empty;
if(System.Web.HttpContext.Current.Cache["KeyName"] == null)
{
name = GetNameMethod();
System.Web.HttpContext.Current.Cache.Add("KeyName", name, null, DateTime.Noew.AddMinutes(5), Cache.NoSlidingExpiration, CacheitemPriority.AboveNormal, null);
}
else
{
name = System.Web.HttpContext.Current.Cache["KeyName"] as string;
}
return name;
}
【讨论】：
AppFabric 缓存 是一种分布式内存缓存技术，它使用跨多个服务器的物理内存以键值对的形式存储数据。 AppFabric 为 .NET Framework 应用程序提供了性能和可伸缩性改进。 Concepts and Architecture
【讨论】：
扩展@Hrvoje Hudo 的答案...
代码：
using System;
using System.Runtime.Caching;
public class InMemoryCache : ICacheService
{
public TValue Get<TValue>(string cacheKey, int durationInMinutes, Func<TValue> getItemCallback) where TValue : class
{
TValue item = MemoryCache.Default.Get(cacheKey) as TValue;
if (item == null)
{
item = getItemCallback();
MemoryCache.Default.Add(cacheKey, item, DateTime.Now.AddMinutes(durationInMinutes));
}
return item;
}
public TValue Get<TValue, TId>(string cacheKeyFormat, TId id, int durationInMinutes, Func<TId, TValue> getItemCallback) where TValue : class
{
string cacheKey = string.Format(cacheKeyFormat, id);
TValue item = MemoryCache.Default.Get(cacheKey) as TValue;
if (item == null)
{
item = getItemCallback(id);
MemoryCache.Default.Add(cacheKey, item, DateTime.Now.AddMinutes(durationInMinutes));
}
return item;
}
}
interface ICacheService
{
TValue Get<TValue>(string cacheKey, Func<TValue> getItemCallback) where TValue : class;
TValue Get<TValue, TId>(string cacheKeyFormat, TId id, Func<TId, TValue> getItemCallback) where TValue : class;
}
示例
单个项目缓存（当每个项目基于其 ID 进行缓存时，因为缓存项目类型的整个目录会过于密集）。
Product product = cache.Get("product_{0}", productId, 10, productData.getProductById);
缓存所有的东西
IEnumerable<Categories> categories = cache.Get("categories", 20, categoryData.getCategories);
为什么是 TId
第二个助手特别好，因为大多数数据键不是复合的。如果您经常使用复合键，则可以添加其他方法。通过这种方式，您可以避免执行各种字符串连接或 string.Formats 来获取传递给缓存助手的键。它还使传递数据访问方法更容易，因为您不必将 ID 传递给包装器方法……对于大多数用例来说，整个事情变得非常简洁和一致。
【讨论】：
这是对 Hrvoje Hudo 答案的改进。此实现有几个关键改进：
请注意，这依赖于 Newtonsoft.Json 来序列化 dependsOn 对象，但可以轻松地将其替换为任何其他序列化方法。
ICache.cs
public interface ICache
{
T GetOrSet<T>(Func<T> getItemCallback, object dependsOn, TimeSpan duration) where T : class;
}
InMemoryCache.cs
using System;
using System.Reflection;
using System.Runtime.Caching;
using Newtonsoft.Json;
public class InMemoryCache : ICache
{
private static readonly object CacheLockObject = new object();
public T GetOrSet<T>(Func<T> getItemCallback, object dependsOn, TimeSpan duration) where T : class
{
string cacheKey = GetCacheKey(getItemCallback, dependsOn);
T item = MemoryCache.Default.Get(cacheKey) as T;
if (item == null)
{
lock (CacheLockObject)
{
item = getItemCallback();
MemoryCache.Default.Add(cacheKey, item, DateTime.Now.Add(duration));
}
}
return item;
}
private string GetCacheKey<T>(Func<T> itemCallback, object dependsOn) where T: class
{
var serializedDependants = JsonConvert.SerializeObject(dependsOn);
var methodType = itemCallback.GetType();
return methodType.FullName + serializedDependants;
}
}
用法：
var order = _cache.GetOrSet(
() => _session.Set<Order>().SingleOrDefault(o => o.Id == orderId)
, new { id = orderId }
, new TimeSpan(0, 10, 0)
);
【讨论】：
if (item == null) 应该在锁内。现在当这个if 在锁之前，就会发生竞争情况。或者更好的是，您应该在锁之前保留if，但重新检查缓存是否仍然是空的，作为锁内的第一行。因为如果两个线程同时到来，它们都会更新缓存。您当前的锁定没有帮助。
public sealed class CacheManager
{
private static volatile CacheManager instance;
private static object syncRoot = new Object();
private ObjectCache cache = null;
private CacheItemPolicy defaultCacheItemPolicy = null;
private CacheEntryRemovedCallback callback = null;
private bool allowCache = true;
private CacheManager()
{
cache = MemoryCache.Default;
callback = new CacheEntryRemovedCallback(this.CachedItemRemovedCallback);
defaultCacheItemPolicy = new CacheItemPolicy();
defaultCacheItemPolicy.AbsoluteExpiration = DateTime.Now.AddHours(1.0);
defaultCacheItemPolicy.RemovedCallback = callback;
allowCache = StringUtils.Str2Bool(ConfigurationManager.AppSettings["AllowCache"]); ;
}
public static CacheManager Instance
{
get
{
if (instance == null)
{
lock (syncRoot)
{
if (instance == null)
{
instance = new CacheManager();
}
}
}
return instance;
}
}
public IEnumerable GetCache(String Key)
{
if (Key == null || !allowCache)
{
return null;
}
try
{
String Key_ = Key;
if (cache.Contains(Key_))
{
return (IEnumerable)cache.Get(Key_);
}
else
{
return null;
}
}
catch (Exception)
{
return null;
}
}
public void ClearCache(string key)
{
AddCache(key, null);
}
public bool AddCache(String Key, IEnumerable data, CacheItemPolicy cacheItemPolicy = null)
{
if (!allowCache) return true;
try
{
if (Key == null)
{
return false;
}
if (cacheItemPolicy == null)
{
cacheItemPolicy = defaultCacheItemPolicy;
}
String Key_ = Key;
lock (Key_)
{
return cache.Add(Key_, data, cacheItemPolicy);
}
}
catch (Exception)
{
return false;
}
}
private void CachedItemRemovedCallback(CacheEntryRemovedArguments arguments)
{
String strLog = String.Concat("Reason: ", arguments.RemovedReason.ToString(), " | Key-Name: ", arguments.CacheItem.Key, " | Value-Object: ", arguments.CacheItem.Value.ToString());
LogManager.Instance.Info(strLog);
}
}
【讨论】：
我使用两个类。第一个缓存核心对象：
public class Cacher<TValue>
where TValue : class
{
#region Properties
private Func<TValue> _init;
public string Key { get; private set; }
public TValue Value
{
get
{
var item = HttpRuntime.Cache.Get(Key) as TValue;
if (item == null)
{
item = _init();
HttpContext.Current.Cache.Insert(Key, item);
}
return item;
}
}
#endregion
#region Constructor
public Cacher(string key, Func<TValue> init)
{
Key = key;
_init = init;
}
#endregion
#region Methods
public void Refresh()
{
HttpRuntime.Cache.Remove(Key);
}
#endregion
}
第二个是缓存对象列表：
public static class Caches
{
static Caches()
{
Languages = new Cacher<IEnumerable<Language>>("Languages", () =>
{
using (var context = new WordsContext())
{
return context.Languages.ToList();
}
});
}
public static Cacher<IEnumerable<Language>> Languages { get; private set; }
}
【讨论】：
我会说在这个持久数据问题上实施 Singleton 可以解决这个问题，以防你发现以前的解决方案非常复杂
public class GPDataDictionary
{
private Dictionary<string, object> configDictionary = new Dictionary<string, object>();
/// <summary>
/// Configuration values dictionary
/// </summary>
public Dictionary<string, object> ConfigDictionary
{
get { return configDictionary; }
}
private static GPDataDictionary instance;
public static GPDataDictionary Instance
{
get
{
if (instance == null)
{
instance = new GPDataDictionary();
}
return instance;
}
}
// private constructor
private GPDataDictionary() { }
} // singleton
【讨论】：
HttpContext.Current.Cache.Insert("subjectlist", subjectlist);
【讨论】：
您也可以尝试使用 ASP MVC 中内置的缓存：
将以下属性添加到您要缓存的控制器方法中：
[OutputCache(Duration=10)]
这种情况下this的ActionResult会被缓存10秒。
更多关于here
【讨论】：