/// <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="tags"> /// A variable-length parameters list containing tags to expire cached /// entries. /// </param> /// <returns>The result of the query.</returns> public static Task <T> FromCacheAsync <T>(this QueryDeferred <T> query, DateTimeOffset absoluteExpiration, params string[] tags) { if (!QueryCacheManager.IsEnabled) { return(Task.Run(() => { return query.Execute(); })); } var key = QueryCacheManager.GetCacheKey(query, tags); var result = Task.Run(() => { var item = QueryCacheManager.Cache.Get(key); if (item == null) { item = query.Execute(); item = QueryCacheManager.Cache.AddOrGetExisting(key, item ?? DBNull.Value, absoluteExpiration) ?? item; QueryCacheManager.AddCacheTag(key, tags); } item = item.IfDbNullThenNull(); return((T)item); }); return(result); }
/// <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="options">The cache entry options 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 Task <T> FromCacheAsync <T>(this QueryDeferred <T> query, MemoryCacheEntryOptions options, params string[] tags) { var key = QueryCacheManager.GetCacheKey(query, tags); var result = Task.Run(() => { object item; if (!QueryCacheManager.Cache.TryGetValue(key, out item)) { item = query.Execute(); item = QueryCacheManager.Cache.Set(key, item ?? DBNull.Value, options); QueryCacheManager.AddCacheTag(key, tags); } else { if (item == DBNull.Value) { item = null; } } return((T)item); }); return(result); }
/// <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 asynchronously 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 Task <T> FromCacheAsync <T>(this QueryDeferred <T> query, CacheItemPolicy policy, params string[] tags) { if (!QueryCacheManager.IsEnabled) { return(Task.Run(() => { return query.Execute(); })); } var key = QueryCacheManager.GetCacheKey(query, tags); var result = Task.Run(() => { var item = QueryCacheManager.GetDeferred(key); if (item == null) { 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); } item = item.IfDbNullThenNull(); return((T)item); }); return(result); }
/// <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">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">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 Task <T> FromCacheAsync <T>(this QueryDeferred <T> query, CacheItemPolicy policy, params string[] tags) { var key = QueryCacheManager.GetCacheKey(query, tags); var result = Task.Run(() => { var item = QueryCacheManager.Cache.Get(key); if (item == null) { item = query.Execute(); item = QueryCacheManager.Cache.AddOrGetExisting(key, item ?? DBNull.Value, policy) ?? item; QueryCacheManager.AddCacheTag(key, tags); } else { if (item == DBNull.Value) { item = null; } } return((T)item); }); return(result); }
public QueryCacheItemTracker Initialize <T>(QueryDeferred <T> query) { if (QueryCacheManager.IsAutoExpireCacheEnabled) { Context = query.Query.GetObjectQuery().Context; AddHook(); } return(this); }
/// <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">The generic type of the query.</typeparam> /// <param name="query">The query to cache in the QueryCacheManager.</param> /// <param name="options">The cache entry options 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, MemoryCacheEntryOptions options, params string[] tags) { var key = QueryCacheManager.GetCacheKey(query, tags); object item; if (!QueryCacheManager.Cache.TryGetValue(key, out item)) { item = query.Execute(); item = QueryCacheManager.Cache.Set(key, item, options); QueryCacheManager.AddCacheTag(key, tags); } 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 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) { var key = QueryCacheManager.GetCacheKey(query, tags); var item = QueryCacheManager.Cache.Get(key); if (item == null) { item = query.Execute(); item = QueryCacheManager.Cache.AddOrGetExisting(key, item, policy) ?? item; QueryCacheManager.AddCacheTag(key, tags); } 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 T FromCache <T>(this QueryDeferred <T> query, DateTimeOffset absoluteExpiration, params string[] tags) { var key = QueryCacheManager.GetCacheKey(query, tags); var item = QueryCacheManager.Cache.Get(key); if (item == null) { item = query.Execute(); item = QueryCacheManager.Cache.AddOrGetExisting(key, item, absoluteExpiration) ?? item; QueryCacheManager.AddCacheTag(key, tags); } 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 in the QueryCacheManager.</param> /// <param name="options">The cache entry options to use to cache the query.</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, MemoryCacheEntryOptions options, CancellationToken cancellationToken = default(CancellationToken), params string[] tags) { var key = QueryCacheManager.GetCacheKey(query, tags); object item; if (!QueryCacheManager.Cache.TryGetValue(key, out item)) { item = await query.ExecuteAsync(cancellationToken).ConfigureAwait(false); item = QueryCacheManager.Cache.Set(key, item ?? DBNull.Value, options); QueryCacheManager.AddCacheTag(key, tags); } 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) { var key = QueryCacheManager.GetCacheKey(query, tags); var item = QueryCacheManager.Cache.Get(key); if (item == null) { item = await query.ExecuteAsync(cancellationToken).ConfigureAwait(false); item = QueryCacheManager.Cache.AddOrGetExisting(key, item ?? DBNull.Value, absoluteExpiration) ?? item; QueryCacheManager.AddCacheTag(key, tags); } 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">The generic type of the query.</typeparam> /// <param name="query">The query to cache in the QueryCacheManager.</param> /// <param name="options">The cache entry options 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, MemoryCacheEntryOptions options, params string[] tags) { if (!QueryCacheManager.IsEnabled) { return(query.Execute()); } var key = QueryCacheManager.GetCacheKey(query, tags); object item; if (!QueryCacheManager.Cache.TryGetValue(key, out item)) { item = query.Execute(); item = QueryCacheManager.Cache.Set(key, item ?? DBNull.Value, options); QueryCacheManager.AddCacheTag(key, tags); } 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">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="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, CacheItemPolicy policy, 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.Cache.Get(key); if (item == null) { item = await query.ExecuteAsync(cancellationToken).ConfigureAwait(false); item = QueryCacheManager.Cache.AddOrGetExisting(key, item ?? DBNull.Value, policy) ?? item; QueryCacheManager.AddCacheTag(key, tags); } 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 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.Cache.Get(key); if (item == null) { item = query.Execute(); item = QueryCacheManager.Cache.AddOrGetExisting(key, item ?? DBNull.Value, policy) ?? item; QueryCacheManager.AddCacheTag(key, tags); } item = item.IfDbNullThenNull(); return((T)item); }
/// <summary>Gets cached keys used to cache or retrieve a query from the QueryCacheManager.</summary> /// <typeparam name="T">Generic type parameter.</typeparam> /// <param name="query">The query to cache or retrieve from the QueryCacheManager.</param> /// <param name="tags">A variable-length parameters list containing tags to create the cache key.</param> /// <returns>The cache key used to cache or retrieve a query from the QueryCacheManager.</returns> public static string GetCacheKey <T>(QueryDeferred <T> query, string[] tags) { var sb = new StringBuilder(); #if EF5 || EF6 var objectQuery = query.Query.GetObjectQuery(); sb.AppendLine(CachePrefix); sb.AppendLine(string.Join(";", tags)); sb.AppendLine(objectQuery.ToTraceString()); foreach (var parameter in objectQuery.Parameters) { sb.Append(parameter.Name); sb.Append(";"); sb.Append(parameter.Value); sb.AppendLine(";"); } #elif EFCORE var command = query.Query.CreateCommand(); sb.AppendLine(CachePrefix); sb.AppendLine(string.Join(";", tags)); sb.AppendLine(command.CommandText); foreach (var parameter in command.Parameters) { sb.Append(parameter.Name); sb.Append(";"); sb.Append(parameter.Value); sb.AppendLine(";"); } #endif return(sb.ToString()); }
/// <summary>Gets cached keys used to cache or retrieve a query from the QueryCacheManager.</summary> /// <typeparam name="T">Generic type parameter.</typeparam> /// <param name="query">The query to cache or retrieve from the QueryCacheManager.</param> /// <param name="tags">A variable-length parameters list containing tags to create the cache key.</param> /// <returns>The cache key used to cache or retrieve a query from the QueryCacheManager.</returns> public static string GetCacheKey <T>(QueryDeferred <T> query, string[] tags) { return(GetCacheKey(query.Query, 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">Generic type parameter.</typeparam> /// <param name="query">The query to cache in the QueryCacheManager.</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, params string[] tags) { return(query.FromCache(QueryCacheManager.DefaultCacheItemPolicy, tags)); }
/// <summary>Gets cached keys used to cache or retrieve a query from the QueryCacheManager.</summary> /// <typeparam name="T">Generic type parameter.</typeparam> /// <param name="query">The query to cache or retrieve from the QueryCacheManager.</param> /// <param name="tags">A variable-length parameters list containing tags to create the cache key.</param> /// <returns>The cache key used to cache or retrieve a query from the QueryCacheManager.</returns> public static string GetCacheKey <T>(QueryDeferred <T> query, string[] tags) { var sb = new StringBuilder(); #if EF5 || EF6 var objectQuery = query.Query.GetObjectQuery(); sb.AppendLine(CachePrefix); if (IncludeConnectionInCacheKey) { var connection = ((EntityConnection)objectQuery.Context.Connection).GetStoreConnection(); // FORCE database name in case "ChangeDatabase()" method is used sb.AppendLine(connection.DataSource ?? ""); sb.AppendLine(connection.Database ?? ""); sb.AppendLine(connection.ConnectionString); } sb.AppendLine(string.Join(";", tags)); #endif #if EF5 sb.AppendLine(objectQuery.ToTraceString()); foreach (var parameter in objectQuery.Parameters) { sb.Append(parameter.Name); sb.Append(";"); sb.Append(parameter.Value); sb.AppendLine(";"); } #elif EF6 var commandTextAndParameters = objectQuery.GetCommandTextAndParameters(); sb.AppendLine(commandTextAndParameters.Item1); foreach (DbParameter parameter in commandTextAndParameters.Item2) { sb.Append(parameter.ParameterName); sb.Append(";"); sb.Append(parameter.Value); sb.AppendLine(";"); } #elif EFCORE RelationalQueryContext queryContext; var command = query.Query.CreateCommand(out queryContext); sb.AppendLine(CachePrefix); if (IncludeConnectionInCacheKey) { var connection = queryContext.Connection.DbConnection; // FORCE database name in case "ChangeDatabase()" method is used sb.AppendLine(connection.DataSource ?? ""); sb.AppendLine(connection.Database ?? ""); sb.AppendLine(connection.ConnectionString); } sb.AppendLine(string.Join(";", tags)); sb.AppendLine(command.CommandText); foreach (var parameter in queryContext.ParameterValues) { sb.Append(parameter.Key); sb.Append(";"); sb.Append(parameter.Value); sb.AppendLine(";"); } #endif return(sb.ToString()); }
/// <summary>Gets cached keys used to cache or retrieve a query from the QueryCacheManager.</summary> /// <typeparam name="T">Generic type parameter.</typeparam> /// <param name="query">The query to cache or retrieve from the QueryCacheManager.</param> /// <param name="tags">A variable-length parameters list containing tags to create the cache key.</param> /// <returns>The cache key used to cache or retrieve a query from the QueryCacheManager.</returns> internal static string GetCacheKey <T>(QueryDeferred <T> query, string[] tags) { return(CachePrefix + string.Join(";", tags) + query.Query.Expression); }
/// <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="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, params string[] tags) { return(query.FromCache(QueryCacheManager.DefaultMemoryCacheEntryOptions, tags)); }
/// <summary> /// Return the result of the <paramref name="query" /> from the cache if possible. Otherwise, materialize /// asynchronously the query and cache the result /// before being returned. /// </summary> /// <typeparam name="T">Generic type parameter.</typeparam> /// <param name="query">The query to cache.</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, params string[] tags) { return(await query.FromCacheAsync(QueryCacheManager.DefaultMemoryCacheEntryOptions, tags)); }
/// <summary> /// Return the result of the <paramref name="query" /> from the cache if possible. Otherwise, /// materialize asynchronously the query and cache the result before being returned. /// </summary> /// <typeparam name="T">Generic type parameter.</typeparam> /// <param name="query">The query to cache.</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 Task <T> FromCacheAsync <T>(this QueryDeferred <T> query, CancellationToken cancellationToken = default(CancellationToken), params string[] tags) { return(query.FromCacheAsync(QueryCacheManager.DefaultMemoryCacheEntryOptions, cancellationToken, 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="options">The cache entry options to use to cache the query.</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 Task <T> FromCacheAsync <T>(this QueryDeferred <T> query, MemoryCacheEntryOptions options, params string[] tags) { return(query.FromCacheAsync(options, default(CancellationToken), tags)); }
/// <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="tags"> /// A variable-length parameters list containing tags to expire cached /// entries. /// </param> /// <returns>The result of the query.</returns> public static Task <T> FromCacheAsync <T>(this QueryDeferred <T> query, params string[] tags) { return(query.FromCacheAsync(QueryCacheManager.DefaultCacheItemPolicy, default(CancellationToken), tags)); }
/// <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="tags"> /// A variable-length parameters list containing tags to expire cached /// entries. /// </param> /// <returns>The result of the query.</returns> public static Task <T> FromCacheAsync <T>(this QueryDeferred <T> query, DateTimeOffset absoluteExpiration, params string[] tags) { return(query.FromCacheAsync(absoluteExpiration, default(CancellationToken), tags)); }