我正在使用MemoryCache。
我已经创建了缓存，并使用5分钟的滑动过期添加了一个条目：
MemoryCache.Default.Set("Key", "Value", new CacheItemPolicy
{
SlidingExpiration = new TimeSpan(0, 5, 0)
});
如果在5分钟内未访问此条目，则会从缓存中删除此条目。如果访问它，则滑动到期计时器将重置为5分钟：
// Resets the sliding expiration:
MemoryCache.Default.Get("Key");
我希望能够选择从缓存中检索条目，而无需重置滑动到期计时器。
似乎不可能，但我想确认一下。
澄清我的具体需求：
我有两个实体，Report和ReportData。 ReportData查询速度很慢。 Report和ReportData都缓存到两个独立的MemoryCache中。
报告MemoryCache在四天后过期。 ReportData MemoryCache将在30分钟后过期。
每当ReportData自然过期时，它会自动刷新并重新缓存。这可确保所有ReportData条目都是新鲜的。
如果用户未在4天内请求报告，则会从缓存中删除报告，同时也会删除相应的ReportData。每当用户请求报告时，此4天计时器应重新启动。
问题是：刷新ReportData需要引用Report。通过其缓存获取对Report的引用会导致缓存计时器重新启动。这是不希望的。只有在用户请求报告时，才应重新启动报告缓存计时器。
潜在的解决方案是引入第三个缓存。另一个缓存将允许外部访问和内部访问的不同过期行为。
这是我目前的代码：
/// <summary>
/// A service for caching Custom reports.
/// </summary>
public class ReportCachingService : ServiceBase
{
/// <summary>
/// Refresh report data every N minutes.
/// </summary>
private int ReportDataRefreshInterval { get; set; }
/// <summary>
/// Remember reports for N days.
/// </summary>
private int MaxReportAge { get; set; }
private MemoryCache ReportDataCache { get; set; }
private MemoryCache ReportCache { get; set; }
private static readonly ILog Logger = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
public ReportCachingService()
{
Logger.Info("ReportCachingService initializing...");
LoadConfiguration();
// Note: The name 'ReportDataCache' must be kept in-sync w/ App.config namedCache entry.
ReportDataCache = new MemoryCache("ReportDataCache");
ReportCache = new MemoryCache("ReportCache");
Logger.Info("ReportCachingService successfully started.");
}
public ReportData GetReportData(int reportID)
{
string key = reportID.ToString();
ReportData reportData = ReportDataCache.Get(key) as ReportData ?? GetAndCacheReportData(reportID);
return reportData;
}
public Report GetReport(int reportID)
{
string key = reportID.ToString();
Report report = ReportCache.Get(key) as Report ?? GetAndCacheReport(reportID);
return report;
}
private void LoadConfiguration()
{
try
{
ReportDataRefreshInterval = GetConfigValue("ReportDataRefreshInterval");
MaxReportAge = GetConfigValue("MaxReportAge"); ;
Logger.Info(string.Format("Configuration loaded. Report data will refresh every {0} minutes. Maximum report age is {1} day(s).", ReportDataRefreshInterval, MaxReportAge));
}
catch (Exception exception)
{
Logger.Error("Error loading configuration.", exception);
throw;
}
}
private static int GetConfigValue(string key)
{
string configValueString = ConfigurationManager.AppSettings[key];
if (string.IsNullOrEmpty(configValueString))
{
throw new Exception(string.Format("Failed to find {0} in App.config", key));
}
int configValue;
bool isValidConfigValue = int.TryParse(configValueString, out configValue);
if (!isValidConfigValue)
{
throw new Exception(string.Format("{0} was found in App.config, but is not a valid integer value.", key));
}
return configValue;
}
private ReportData GetAndCacheReportData(int reportID)
{
Report report = GetReport(reportID);
ReportData reportData = report.GetData(false, "Administrator");
if (reportData == null)
{
string errorMessage = string.Format("Failed to find reportData for report with ID: {0}", reportID);
Logger.Error(errorMessage);
throw new Exception(errorMessage);
}
// SlidingExpiration forces cache expiration to refresh when an entry is accessed.
TimeSpan reportDataCacheExpiration = new TimeSpan(0, ReportDataRefreshInterval, 0);
string key = reportID.ToString();
ReportDataCache.Set(key, reportData, new CacheItemPolicy
{
SlidingExpiration = reportDataCacheExpiration,
UpdateCallback = OnReportDataUpdate
});
return reportData;
}
private Report GetAndCacheReport(int reportID)
{
// If the ReportCache does not contain the Report - attempt to load it from DB.
Report report = Report.Load(reportID);
if (report == null)
{
string errorMessage = string.Format("Failed to find report with ID: {0}", reportID);
Logger.Error(errorMessage);
throw new Exception(errorMessage);
}
// SlidingExpiration forces cache expiration to refresh when an entry is accessed.
TimeSpan reportCacheExpiration = new TimeSpan(MaxReportAge, 0, 0, 0);
string key = reportID.ToString();
ReportCache.Set(key, report, new CacheItemPolicy
{
SlidingExpiration = reportCacheExpiration,
RemovedCallback = OnReportRemoved
});
return report;
}
private void OnReportRemoved(CacheEntryRemovedArguments arguments)
{
Logger.DebugFormat("Report with ID {0} has expired with reason: {1}.", arguments.CacheItem.Key, arguments.RemovedReason);
// Clear known ReportData for a given Report whenever the Report expires.
ReportDataCache.Remove(arguments.CacheItem.Key);
}
private void OnReportDataUpdate(CacheEntryUpdateArguments arguments)
{
Logger.DebugFormat("ReportData for report with ID {0} has updated with reason: {1}.", arguments.UpdatedCacheItem.Key, arguments.RemovedReason);
// Expired ReportData should be automatically refreshed by loading fresh values from the DB.
if (arguments.RemovedReason == CacheEntryRemovedReason.Expired)
{
int reportID = int.Parse(arguments.Key);
GetAndCacheReportData(reportID);
}
}
}
答案 0 :(得分：-1)
最好使用单独的类进行内存缓存。这是一个样本。
public class MyMemoryCache
{
private readonly ObjectCache _cache;
public MyMemoryCache()
{
_cache = MemoryCache.Default;
}
/// <summary>
/// Get an object from cache
/// </summary>
/// <param name="cacheKey"></param>
/// <returns></returns>
public object Get(string cacheKey)
{
return _cache.Get(cacheKey);
}
/// <summary>
/// check if the object is available in the cache
/// </summary>
/// <param name="cacheKey"></param>
/// <returns></returns>
public bool Contains(string cacheKey)
{
return _cache.Contains(cacheKey);
}
/// <summary>
/// Add an objct in to the cache
/// </summary>
/// <param name="objectToBeChached"></param>
/// <param name="cacheKey"></param>
public void Add(string cacheKey, object objectToBeChached)
{
var cacheItemPolicy = new CacheItemPolicy { AbsoluteExpiration = DateTime.Now.AddMinutes(5.0) };
_cache.Add(cacheKey, objectToBeChached, cacheItemPolicy);
}
}