/// <summary>
/// Return the result of the <paramref name="query" /> from the cache. If the query is not cached
/// yet, the query is materialized and cached before being returned.
/// </summary>
/// <typeparam name="T">Generic type parameter.</typeparam>
/// <param name="query">The query to cache in the QueryCacheManager.</param>
/// <param name="absoluteExpiration">The fixed date and time at which the cache entry will expire.</param>
/// <param name="tags">
/// A variable-length parameters list containing tags to expire cached
/// entries.
/// </param>
/// <returns>The result of the query.</returns>
public static T FromCache <T>(this QueryDeferred <T> query, DateTimeOffset absoluteExpiration, params string[] tags)
{
if (!QueryCacheManager.IsEnabled)
{
return(query.Execute());
}
var key = QueryCacheManager.GetCacheKey(query, tags);
var item = QueryCacheManager.GetDeferred(key);
if (item == null)
{
#if EF6
using (var handler = new QueryCacheItemTracker().Initialize(query))
{
item = query.Execute();
item = QueryCacheManager.AddOrGetExistingDeferred <T>(key, item ?? DBNull.Value, absoluteExpiration) ?? item;
QueryCacheManager.AddCacheTag(handler, key, tags);
}
#else
item = query.Execute();
item = QueryCacheManager.AddOrGetExistingDeferred <T>(key, item ?? DBNull.Value, absoluteExpiration) ?? item;
QueryCacheManager.AddCacheTag(key, tags);
#endif
}
item = item.IfDbNullThenNull();
return((T)item);
}
/// <summary>
/// Return the result of the <paramref name="query" /> from the cache. If the query is not cached
/// yet, the query is materialized asynchronously and cached before being returned.
/// </summary>
/// <typeparam name="T">Generic type parameter.</typeparam>
/// <param name="query">The query to cache in the QueryCacheManager.</param>
/// <param name="absoluteExpiration">The fixed date and time at which the cache entry will expire.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="tags">
/// A variable-length parameters list containing tags to expire cached
/// entries.
/// </param>
/// <returns>The result of the query.</returns>
public static async Task <T> FromCacheAsync <T>(this QueryDeferred <T> query, DateTimeOffset absoluteExpiration, CancellationToken cancellationToken = default(CancellationToken), params string[] tags)
{
if (!QueryCacheManager.IsEnabled)
{
return(await query.ExecuteAsync(cancellationToken).ConfigureAwait(false));
}
var key = QueryCacheManager.GetCacheKey(query, tags);
var item = QueryCacheManager.GetDeferred(key);
if (item == null)
{
using (var handler = new QueryCacheItemTracker().Initialize(query))
{
item = await query.ExecuteAsync(cancellationToken).ConfigureAwait(false);
item = QueryCacheManager.AddOrGetExistingDeferred <T>(key, item ?? DBNull.Value, absoluteExpiration) ?? item;
QueryCacheManager.AddCacheTag(handler, key, tags);
QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
}
}
item = item.IfDbNullThenNull();
return((T)item);
}
/// <summary>
/// Return the result of the <paramref name="query" /> from the cache. If the query is not cached
/// yet, the query is materialized and cached before being returned.
/// </summary>
/// <typeparam name="T">Generic type parameter.</typeparam>
/// <param name="query">The query to cache in the QueryCacheManager.</param>
/// <param name="absoluteExpiration">The fixed date and time at which the cache entry will expire.</param>
/// <param name="tags">
/// A variable-length parameters list containing tags to expire cached
/// entries.
/// </param>
/// <returns>The result of the query.</returns>
public static IEnumerable <T> FromCache <T>(this IQueryable <T> query, DateTimeOffset absoluteExpiration, params string[] tags) where T : class
{
if (!QueryCacheManager.IsEnabled)
{
return(query.AsNoTracking().ToList());
}
var key = QueryCacheManager.GetCacheKey(query, tags);
var item = QueryCacheManager.Get <List <T> >(key);
if (item == null)
{
#if EF6
using (var handler = new QueryCacheItemTracker().Initialize(query))
{
item = query.AsNoTracking().ToList();
item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;
QueryCacheManager.AddCacheTag(handler, key, tags);
}
#else
item = query.AsNoTracking().ToList();
item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;
QueryCacheManager.AddCacheTag(key, tags);
#endif
}
return((IEnumerable <T>)item);
}
/// <summary>
/// Return the result of the <paramref name="query" /> from the cache. If the query is not cached
/// yet, the query is materialized asynchronously and cached before being returned.
/// </summary>
/// <typeparam name="T">Generic type parameter.</typeparam>
/// <param name="query">The query to cache in the QueryCacheManager.</param>
/// <param name="absoluteExpiration">The fixed date and time at which the cache entry will expire.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="tags">
/// A variable-length parameters list containing tags to expire cached
/// entries.
/// </param>
/// <returns>The result of the query.</returns>
public static async Task <IEnumerable <T> > FromCacheAsync <T>(this IQueryable <T> query, DateTimeOffset absoluteExpiration, CancellationToken cancellationToken = default(CancellationToken), params string[] tags) where T : class
{
if (!QueryCacheManager.IsEnabled)
{
return(await query.AsNoTracking().ToListAsync(cancellationToken).ConfigureAwait(false));
}
var key = QueryCacheManager.GetCacheKey(query, tags);
var item = QueryCacheManager.Get <List <T> >(key);
if (item == null)
{
using (var handler = new QueryCacheItemTracker().Initialize(query))
{
item = await query.AsNoTracking().ToListAsync(cancellationToken).ConfigureAwait(false);
item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;
QueryCacheManager.AddCacheTag(handler, key, tags);
QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
}
}
return((IEnumerable <T>)item);
}
internal static void AddCacheTag(QueryCacheItemTracker handler, string cacheKey, params string[] tags)
{
if (IsAutoExpireCacheEnabled && handler.HookAdded)
{
var model = handler.Context.GetDbContext().GetModel();
var types = handler.MaterializedEntities.Select(x => ObjectContext.GetObjectType(x.GetType())).Distinct().ToList();
var entitySetNames = new List <string>();
foreach (var type in types)
{
var conceptual = model.ConceptualModel.EntityTypes.FirstOrDefault(x => x.Name == type.Name);
if (conceptual == null)
{
// we don't care, the cache will simply not be reset
continue;
}
entitySetNames.Add(conceptual.EntitySet.Name);
}
if (tags == null)
{
tags = new string[0];
}
var tagsList = tags.ToList();
tagsList.AddRange(entitySetNames.Select(x => PrefixTagSet + x));
tags = tagsList.ToArray();
}
AddCacheTag(cacheKey, tags);
}
/// <summary>
/// Return the result of the <paramref name="query" /> from the cache. If the query is not cached
/// yet, the query is materialized and cached before being returned.
/// </summary>
/// <typeparam name="T">The generic type of the query.</typeparam>
/// <param name="query">The query to cache in the QueryCacheManager.</param>
/// <param name="policy">The policy to use to cache the query.</param>
/// <param name="tags">
/// A variable-length parameters list containing tags to expire cached
/// entries.
/// </param>
/// <returns>The result of the query.</returns>
public static IEnumerable <T> FromCache <T>(this IQueryable <T> query, CacheItemPolicy policy, params string[] tags) where T : class
{
if (!QueryCacheManager.IsEnabled)
{
return(query.AsNoTracking().ToList());
}
var key = QueryCacheManager.GetCacheKey(query, tags);
var item = QueryCacheManager.Get <List <T> >(key);
if (item == null)
{
#if EF6
using (var handler = new QueryCacheItemTracker().Initialize(query))
{
item = query.AsNoTracking().ToList();
item = QueryCacheManager.AddOrGetExisting(key, item, policy) ?? item;
QueryCacheManager.AddCacheTag(handler, key, tags);
QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
}
#else
item = query.AsNoTracking().ToList();
item = QueryCacheManager.AddOrGetExisting(key, item, policy) ?? item;
QueryCacheManager.AddCacheTag(key, tags);
QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
#endif
}
return((IEnumerable <T>)item);
}
/// <summary>
/// Return the result of the <paramref name="query" /> from the cache. If the query is not cached
/// yet, the query is materialized and cached before being returned.
/// </summary>
/// <typeparam name="T">The generic type of the query.</typeparam>
/// <param name="query">The query to cache in the QueryCacheManager.</param>
/// <param name="policy">The policy to use to cache the query.</param>
/// <param name="tags">
/// A variable-length parameters list containing tags to expire cached
/// entries.
/// </param>
/// <returns>The result of the query.</returns>
public static T FromCache <T>(this QueryDeferred <T> query, CacheItemPolicy policy, params string[] tags)
{
if (!QueryCacheManager.IsEnabled)
{
return(query.Execute());
}
var key = QueryCacheManager.GetCacheKey(query, tags);
var item = QueryCacheManager.GetDeferred(key);
if (item == null)
{
#if EF6
using (var handler = new QueryCacheItemTracker().Initialize(query))
{
item = query.Execute();
item = QueryCacheManager.AddOrGetExistingDeferred <T>(key, item ?? DBNull.Value, policy) ?? item;
QueryCacheManager.AddCacheTag(handler, key, tags);
QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
}
#else
item = query.Execute();
item = QueryCacheManager.AddOrGetExistingDeferred <T>(key, item ?? DBNull.Value, policy) ?? item;
QueryCacheManager.AddCacheTag(key, tags);
QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
#endif
}
item = item.IfDbNullThenNull();
return((T)item);
}
/// <summary>
/// Return the result of the <paramref name="query" /> from the cache. If the query is not cached yet, the query
/// is materialized and cached before being returned.
/// </summary>
/// <typeparam name="T">The generic type of the query.</typeparam>
/// <param name="query">The query to cache the result.</param>
/// <param name="policy">The eviction details for the cached result.</param>
/// <param name="tags">(Optional) The tag list that can be used to expire cached result.</param>
/// <returns>The result of the query.</returns>
public static IEnumerable <T> FromCache <T>(this DbRawSqlQuery <T> query, CacheItemPolicy policy, params string[] tags) where T : class
{
if (!QueryCacheManager.IsEnabled)
{
return(query.ToList());
}
var key = QueryCacheManager.GetCacheKey(query, tags);
var item = QueryCacheManager.Get <List <T> >(key);
if (item == null)
{
using (var handler = new QueryCacheItemTracker().Initialize(query))
{
item = query.ToList();
item = QueryCacheManager.AddOrGetExisting(key, item, policy) ?? item;
QueryCacheManager.AddCacheTag(handler, key, tags);
}
}
return((IEnumerable <T>)item);
}
/// <summary>
/// Return the result of the <paramref name="query" /> from the cache. If the query is not cached yet, the query
/// is materialized and cached before being returned.
/// </summary>
/// <typeparam name="T">The generic type of the query.</typeparam>
/// <param name="query">The query to cache the result.</param>
/// <param name="absoluteExpiration">The fixed date and time at which the cache entry will expire.</param>
/// <param name="tags">(Optional) The tag list that can be used to expire cached result.</param>
/// <returns>The result of the query.</returns>
public static IEnumerable <T> FromCache <T>(this DbRawSqlQuery <T> query, DateTimeOffset absoluteExpiration, params string[] tags) where T : class
{
if (!QueryCacheManager.IsEnabled)
{
return(query.ToList());
}
var key = QueryCacheManager.GetCacheKey(query, tags);
var item = QueryCacheManager.Get <List <T> >(key);
if (item == null)
{
using (var handler = new QueryCacheItemTracker().Initialize(query))
{
item = query.ToList();
item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;
QueryCacheManager.AddCacheTag(handler, key, tags);
QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
}
}
return((IEnumerable <T>)item);
}