public void InsertData(IProcessManagerData data)
{
Type typeParameterType = data.GetType();
MethodInfo md = GetType().GetTypeInfo().GetMethods().First(m => m.Name == "GetMemoryData" && m.GetParameters()[0].Name == "data");
//MethodInfo genericMd = md.MakeGenericMethod(typeParameterType);
MethodInfo genericMd = md.MakeGenericMethod(typeof(IProcessManagerData));
lock (_memoryCacheLock)
{
var memoryData = genericMd.Invoke(this, new object[] { data });
string key = data.CorrelationId.ToString();
//if (!Cache.Contains(key))
//{
// Cache.Set(key, memoryData, _policy);
//}
//else
//{
// throw new ArgumentException(string.Format("ProcessManagerData with CorrelationId {0} already exists in the cache.", key));
//}
if (!_provider.Contains(key))
{
_provider.Add(key, memoryData, _absoluteExpiry);
}
else
{
throw new ArgumentException(string.Format("ProcessManagerData with CorrelationId {0} already exists in the cache.", key));
}
}
}
public int ReserveId <T>(TimeSpan howLong)
{
var cacheKey = GetCacheKey <T>();
var idGroup = _cache.Get(cacheKey);
if (idGroup == null || !idGroup.Any())
{
//then we need to fill this group
var idsFromSource = idSource.GetIds <T>(FetchSize);
idGroup.AddRange(idsFromSource);
}
if (!idGroup.Any())
{
throw new Exception("Failed to get new id:s from source");
}
var nextId = idGroup.FirstOrDefault();
idGroup.Remove(nextId);
_cache.Put(cacheKey, idGroup, TimeSpan.FromDays(365));
var reserveKey = GetReservationKey <T>(nextId);
if (_cache.Contains(reserveKey))
{
throw new Exception("ID " + nextId + " has already been reserved");
}
_cache.Put(reserveKey, nextId, howLong);
return(nextId);
}
/// <summary>
/// 正常讀取緩存數據：緩存中沒有，則執行獲取數據方法
/// </summary>
/// <typeparam name="T">緩存值類型</typeparam>
/// <param name="cacheKey">key</param>
/// <param name="acquirer">獲取原始數據方法</param>
/// <param name="cachePolicy">緩存過期策略</param>
/// <returns>緩存結果</returns>
private T GetCahcheValueByCommonRead <T>(CacheKey cacheKey, Func <T> acquirer, CachePolicy cachePolicy)
{
string strKey = cacheKey.Key;
if (cacheProvider.Contains(strKey))
{
var value = cacheProvider.Get <T>(strKey);
ProlongCacheValueLifeTime(cacheKey, cachePolicy, value);
return(value);
}
else
{
if (acquirer == null)
{
return(default(T));
}
using (cacheProvider.EnterReadLock())
{
if (!cacheProvider.Contains(strKey))
{
var value = acquirer();
this.Set(cacheKey, value, cachePolicy);
return(value);
}
}
return(this.Get <T>(strKey));
}
}
public T Get <T>(string key)
{
GuardHelper.ArgumentNotEmpty(() => key);
if (cacheProvider.Contains(key))
{
return(cacheProvider.Get <T>(key));
}
else
{
return(default(T));
}
}
public void Intercept(IInvocation invocation)
{
var cacheAttr = GetCacheResultAttribute(invocation);
if (cacheAttr == null)
{
invocation.Proceed();
return;
}
string key = GetInvocationSignature(invocation);
if (_cache.Contains(key))
{
invocation.ReturnValue = _cache.Get(key);
return;
}
invocation.Proceed();
var result = invocation.ReturnValue;
if (result != null)
{
_cache.Put(key, result, cacheAttr.Duration);
}
}
public override IEnumerable <T> Find(System.Linq.Expressions.Expression <Func <T, bool> > where, params System.Linq.Expressions.Expression <Func <T, object> >[] includeProperties)
{
IEnumerable <T> query = _surrogate.Find(where, includeProperties).AsQueryable();
if (!_cacheProvider.Contains(query))
{
CacheItemPolicy policy = WrapPolicy();
_cacheProvider.Add(query, policy);
}
else
{
query = _cacheProvider.Get(query);
}
return(query);
}
public object Invoke(object instance, object[] inputs, out object[] outputs)
{
object o = null;
string key = GenerateCachekey();
if (provider.Contains(key))
{
outputs = new object[] { };
WebOperationContext.Current.OutgoingResponse.Headers.Add("X-Cache-Lookup", "NetHttpService Cache Extension v1.0 ");
CacheEntry entry = provider.GetData <CacheEntry>(key);
WebOperationContext.Current.OutgoingResponse.ContentType = entry.ContentType;
o = new MemoryStream(entry.Response);
}
else
{
o = innerInvoker.Invoke(instance, inputs, out outputs);
byte[] bytes = GetBytes((Stream)o);
WebOperationContext.Current.OutgoingResponse.Headers.Add("X-Cache", "MISS from NetHttpService Cache Extension v1.0 ");
CacheEntry entry = new CacheEntry()
{
ContentType = WebOperationContext.Current.OutgoingResponse.ContentType, Response = bytes
};
provider.Add(key, entry);
}
return(o);
}
public void TestUsage()
{
_provider.Add("test", "value", DateTimeOffset.MaxValue, "region");
Assert.That(_provider.Contains("test", "region"), Is.True);
Assert.That(_provider.Get("test", "region"), Is.EqualTo("value"));
}
public IDictionary <TId, TEntity> GetCacheFor <TEntity, TId>() where TEntity : IEntity <TId>
{
string key = GetEntityCacheKey <TEntity, TId>();
if (!_rawCache.Contains(key))
{
var newCache = ConcurrentDictionaryProvider.Create <TEntity, TId>();
_rawCache.Put(key, newCache, new SlidingExpirationPolicy(key, newCache, EntityAccessTimeout));
}
return(_rawCache.Get <IDictionary <TId, TEntity> >(key));
}
public async Task <IContent> GetNextFile(CancellationToken token)
{
var path = _history.GetNext();
_history.CurrentIndex++;
if (!NextFileExists)
{
return(_cache.Get(path) as IContent);
}
var newNextPath = _history.GetNext();
if (_cache.Contains(newNextPath))
{
return(_cache.Get(path) as IContent);
}
bool cachingIsCompleted = false;
while (!cachingIsCompleted)
{
try
{
var newNextContent = await _baseModel.GetContent(newNextPath, token);
_cache.Add(newNextPath, newNextContent);
cachingIsCompleted = true;
}
catch (FileNotFoundException e)
{
_history.Remove(newNextPath);
cachingIsCompleted = !NextFileExists;
if (!cachingIsCompleted)
{
newNextPath = _history.GetNext();
}
}
}
return(_cache.Get(path) as IContent);
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (_cache.Contains(request))
{
return(_cache[request]);
}
else
{
var response = base.SendAsync(request, cancellationToken);
_cache[request] = response;
return(response);
}
}
public void InsertData(object data, string name)
{
lock (_memoryCacheLock)
{
if (_provider.Contains(name))
{
var cacheItem = _provider.Get <string, object>(name);
((IList <MemoryData <object> >)cacheItem).Add(new MemoryData <object>
{
Data = data
});
}
else
{
_provider.Add(name, new List <MemoryData <object> >
{
new MemoryData <object>
{
Data = data
}
}, _absoluteExpiry);
}
}
}
public void FillCache(CachedAttribute attribute, IInvocation invocation)
{
var cacheKeyGenerator = _cacheKeyGenerators.FirstOrDefault(c => c.GetType() == attribute.CacheKeyGenerator) ?? new DefaultCacheKeyGenerator();
var cacheKey = cacheKeyGenerator.GenerateCacheKey(invocation.Method, invocation.Arguments);
if (_cache.Contains(cacheKey, attribute.CacheRegion))
{
invocation.ReturnValue = _cache.Get(cacheKey, attribute.CacheRegion);
}
else
{
invocation.Proceed();
var expiration = attribute.TimeoutInMinutes == 0 ? DateTimeOffset.MaxValue : DateTimeOffset.Now.AddMinutes(attribute.TimeoutInMinutes);
_cache.Add(cacheKey, invocation.ReturnValue, expiration, attribute.CacheRegion);
}
}
public int GetProductSaleAmounts(int productId)
{
var key = productId.ToString();
if (_cacheProvider.Contains(key))
{
var output = _cacheProvider.Get(key);
return(Convert.ToInt32(output));
}
else
{
var productStatements = _repository.GetProductStatements();
var sum = productStatements.Sum(x => x.Amount);
_cacheProvider.Put(key, sum.ToString(), 10000);
return(sum);
}
}
public static bool Contains <T>(this ICacheProvider cache, Guid uid) where T : EntityModel, new() => cache.Contains(GetKey <T>(uid));
public bool Contains(string key)
{
return(cache.Contains(key));
}
public static IEnumerable <T> FromCache <T>(this IEnumerable <T> query)
{
ICacheProvider provider = Config.Cache.DefaultProvider;
return(provider.Contains(query) ? provider.Get(query) : query);
}
public void Intercept(IInvocation invocation)
{
var cacheMethodAttr = GetCacheMethodAttribute(invocation);
var cacheClassAttr = GetCacheClassAttribute(invocation);
// Method attribute has more priority than class attribute
var cacheAttr = cacheMethodAttr ?? cacheClassAttr;
// If method has [DoNotCache] attribute, then don't cache it
var doNotCacheAttribute = GetDontCacheMethodAttribute(invocation);
if (doNotCacheAttribute != null)
{
cacheAttr = null;
}
if (cacheAttr == null)
{
invocation.Proceed();
return;
}
if (invocation.Method.ReturnType == typeof(void) || invocation.Method.ReturnType == typeof(Task))
{
// If attribute is on a method that doesn't have result value than throw exception
if (cacheMethodAttr != null)
{
throw new InvalidOperationException($"Method \"{invocation.Method.Name}\" with attribute [{nameof(CacheAttribute)}] must return a value, not 'void' or 'Task'.");
}
// Otherwise it's on the class - do not intercept
invocation.Proceed();
return;
}
var key = GetInvocationSignature(invocation);
if (_cache.Contains(key))
{
invocation.ReturnValue = _cache.Get(key);
return;
}
invocation.Proceed();
var method = invocation.MethodInvocationTarget;
var isAsync = method.GetCustomAttribute(typeof(AsyncStateMachineAttribute)) != null;
if (isAsync && typeof(Task).IsAssignableFrom(method.ReturnType))
{
invocation.ReturnValue = InterceptAsync((dynamic)invocation.ReturnValue);
OnFinish();
}
else
{
OnFinish();
}
void OnFinish()
{
var result = invocation.ReturnValue;
if (result != null)
{
_cache.Put(key, result, cacheAttr.Duration);
}
}
}
public bool Contains(string key)
{
return cacheProvider.Contains(key);
}
