Update source

JonathanMagnan · JonathanMagnan · commit e199af03c290 · 2020-05-05T19:04:42.000-04:00
Update source
diff --git a/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/DbRawSqlQuery/FromCache.cs b/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/DbRawSqlQuery/FromCache.cs
@@ -51,7 +51,8 @@ public static IEnumerable<T> FromCache<T>(this DbRawSqlQuery<T> query, CacheItem
                 {
                     item = query.ToList();
                     item = QueryCacheManager.AddOrGetExisting(key, item, policy) ?? item;
-                    QueryCacheManager.AddCacheTag(handler, key, tags);
+                    QueryCacheManager.AddCacheTag(handler, key, tags); 
+                    QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
                 }
             }
 
@@ -85,6 +86,7 @@ public static IEnumerable<T> FromCache<T>(this DbRawSqlQuery<T> query, DateTimeO
                     item = query.ToList();
                     item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;
                     QueryCacheManager.AddCacheTag(handler, key, tags);
+                    QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
                 }
             }
 
diff --git a/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/DbSet/ExpireType.cs b/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/DbSet/ExpireType.cs
@@ -0,0 +1,21 @@
+﻿using System.Data.Common;
+using System.Reflection;
+#if EFCORE
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage;
+#elif EF6 || EF5 || EFCLASSIC
+using System.Data.Entity;
+#endif
+namespace Z.EntityFramework.Plus
+{
+	public static partial class DbSetExtensions
+	{
+        /// <summary>A DbSet&lt;T&gt; extension method that expire cache.</summary>
+        /// <param name="dbSet">The dbSet to act on.</param>
+        public static void ExpireCache<T>(this DbSet<T> dbSet) where T : class
+		{
+			QueryCacheManager.ExpireType(typeof(T));
+		}
+	}
+}  
diff --git a/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/DbSqlQuery/FromCache.cs b/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/DbSqlQuery/FromCache.cs
@@ -52,6 +52,7 @@ public static IEnumerable<T> FromCache<T>(this DbSqlQuery<T> query, CacheItemPol
                     item = query.AsNoTracking().ToList();
                     item = QueryCacheManager.AddOrGetExisting(key, item, policy) ?? item;
                     QueryCacheManager.AddCacheTag(handler, key, tags);
+                    QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
                 }
             }
 
@@ -85,6 +86,7 @@ public static IEnumerable<T> FromCache<T>(this DbSqlQuery<T> query, DateTimeOffs
                     item = query.AsNoTracking().ToList();
                     item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;
                     QueryCacheManager.AddCacheTag(handler, key, tags);
+                    QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
                 }
             }
 
diff --git a/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/IQueryable`/FromCache.cs b/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/IQueryable`/FromCache.cs
@@ -54,11 +54,13 @@ public static IEnumerable<T> FromCache<T>(this IQueryable<T> query, CacheItemPol
                     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
             }
 
@@ -96,11 +98,13 @@ public static IEnumerable<T> FromCache<T>(this IQueryable<T> query, DateTimeOffs
                     item = query.AsNoTracking().ToList();
                     item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;
                     QueryCacheManager.AddCacheTag(handler, key, tags);
+                    QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
                 }
 #else           
                 item = query.AsNoTracking().ToList();
                 item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;
                 QueryCacheManager.AddCacheTag(key, tags);
+                QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
 #endif
             }
 
@@ -150,6 +154,7 @@ public static IEnumerable<T> FromCache<T>(this IQueryable<T> query, MemoryCacheE
                 item = query.AsNoTracking().ToList();
                 item = QueryCacheManager.Cache.Set(key, item, options);
                 QueryCacheManager.AddCacheTag(key, tags);
+                QueryCacheManager.AddCacheTag(key,typeof(T).Name  + QueryCacheManager.CacheTypeSuffix);
             }
 
             item = item.IfDbNullThenNull();
diff --git a/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/IQueryable`/FromCacheAsync.cs b/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/IQueryable`/FromCacheAsync.cs
@@ -58,6 +58,7 @@ public static Task<IEnumerable<T>> FromCacheAsync<T>(this IQueryable<T> query, C
                     item = query.AsNoTracking().ToList();
                     item = QueryCacheManager.AddOrGetExisting(key, item, policy) ?? item;
                     QueryCacheManager.AddCacheTag(key, tags);
+                    QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
                 }
 
                 return (IEnumerable<T>) item;
@@ -98,6 +99,7 @@ public static Task<IEnumerable<T>> FromCacheAsync<T>(this IQueryable<T> query, D
                     item = query.AsNoTracking().ToList();
                     item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;
                     QueryCacheManager.AddCacheTag(key, tags);
+                    QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
                 }
 
                 return (IEnumerable<T>) item;
@@ -153,6 +155,7 @@ public static Task<IEnumerable<T>> FromCacheAsync<T>(this IQueryable<T> query, p
                     item = await query.AsNoTracking().ToListAsync(cancellationToken).ConfigureAwait(false);
                     item = QueryCacheManager.AddOrGetExisting(key, item, policy) ?? item;
                     QueryCacheManager.AddCacheTag(handler, key, tags);
+                    QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
                 }
             }
 
@@ -207,6 +210,7 @@ public static Task<IEnumerable<T>> FromCacheAsync<T>(this IQueryable<T> query, C
                     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);
                 }
             }
 
@@ -291,6 +295,7 @@ public static Task<IEnumerable<T>> FromCacheAsync<T>(this IQueryable<T> query, p
                 item = await query.AsNoTracking().ToListAsync(cancellationToken).ConfigureAwait(false);
                 item = QueryCacheManager.Cache.Set(key, item, options);
                 QueryCacheManager.AddCacheTag(key, tags);
+                QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
             }
 
             item = item.IfDbNullThenNull();
diff --git a/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/QueryDeferred`/FromCache.cs b/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/QueryDeferred`/FromCache.cs
@@ -52,12 +52,14 @@ public static T FromCache<T>(this QueryDeferred<T> query, CacheItemPolicy policy
 
                     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
             }
 
@@ -98,12 +100,14 @@ public static T FromCache<T>(this QueryDeferred<T> query, DateTimeOffset absolut
 
                     item = QueryCacheManager.AddOrGetExistingDeferred<T>(key, item ?? DBNull.Value, absoluteExpiration) ?? 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, absoluteExpiration) ?? item;
                 QueryCacheManager.AddCacheTag(key, tags);
+                QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
 #endif
             }
 
@@ -156,6 +160,7 @@ public static T FromCache<T>(this QueryDeferred<T> query, MemoryCacheEntryOption
 
                 item = QueryCacheManager.Cache.Set(key, item ?? DBNull.Value, options);
                 QueryCacheManager.AddCacheTag(key, tags);
+                QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
             }
 
             item = item.IfDbNullThenNull();
diff --git a/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/QueryDeferred`/FromCacheAsync.cs b/src/shared/Z.EF.Plus.QueryCache.Shared/Extensions/QueryDeferred`/FromCacheAsync.cs
@@ -56,6 +56,7 @@ public static Task<T> FromCacheAsync<T>(this QueryDeferred<T> query, CacheItemPo
                     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();
@@ -99,6 +100,7 @@ public static Task<T> FromCacheAsync<T>(this QueryDeferred<T> query, DateTimeOff
                     item = query.Execute();
                     item = QueryCacheManager.AddOrGetExistingDeferred<T>(key, item ?? DBNull.Value, absoluteExpiration) ?? item;
                     QueryCacheManager.AddCacheTag(key, tags);
+					QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
                 }
 
                 item = item.IfDbNullThenNull();
@@ -156,6 +158,7 @@ public static Task<T> FromCacheAsync<T>(this QueryDeferred<T> query, params stri
                     item = await query.ExecuteAsync(cancellationToken).ConfigureAwait(false);
                     item = QueryCacheManager.AddOrGetExistingDeferred<T>(key, item ?? DBNull.Value, policy) ?? item;
                     QueryCacheManager.AddCacheTag(handler, key, tags);
+                    QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);
                 }
             }
 
@@ -212,6 +215,7 @@ public static Task<T> FromCacheAsync<T>(this QueryDeferred<T> query, CacheItemPo
                     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);
                 }
             }
 
@@ -298,6 +302,7 @@ public static Task<T> FromCacheAsync<T>(this QueryDeferred<T> query, params stri
                 item = await query.ExecuteAsync(cancellationToken).ConfigureAwait(false);
                 item = QueryCacheManager.Cache.Set(key, item ?? DBNull.Value, options);
                 QueryCacheManager.AddCacheTag(key, tags);
+                QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix); 
             }
 
             item = item.IfDbNullThenNull();
diff --git a/src/shared/Z.EF.Plus.QueryCache.Shared/QueryCacheManager.cs b/src/shared/Z.EF.Plus.QueryCache.Shared/QueryCacheManager.cs
@@ -51,9 +51,10 @@ static QueryCacheManager()
             DefaultCacheItemPolicy = new CacheItemPolicy();
 #elif EFCORE
             Cache = new MemoryCache(new MemoryCacheOptions());
-            DefaultMemoryCacheEntryOptions = new MemoryCacheEntryOptions();
+            DefaultMemoryCacheEntryOptions = new MemoryCacheEntryOptions(); 
 #endif
             CachePrefix = "Z.EntityFramework.Plus.QueryCacheManager;";
+            CacheTypeSuffix = "_ZZZ_QueryCacheManager_CacheType";
             CacheTags = new ConcurrentDictionary<string, List<string>>();
             IncludeConnectionInCacheKey = true;
         }
@@ -182,13 +183,17 @@ public static Func<MemoryCacheEntryOptions> MemoryCacheEntryOptionsFactory
                 _memoryCacheEntryOptionsFactory = value;
                 _defaultMemoryCacheEntryOptions = null;
             }
-        }
+        }  
 #endif
 
         /// <summary>Gets or sets the cache prefix to use to create the cache key.</summary>
         /// <value>The cache prefix to use to create the cache key.</value>
         public static string CachePrefix { get; set; }
 
+        /// <summary>Gets or sets the cache type suffix.</summary>
+        /// <value>The cache type suffix.</value>
+        public static string CacheTypeSuffix { get; set; }
+
         /// <summary>Gets or sets the cache key factory.</summary>
         /// <value>The cache key factory.</value>
         public static Func<IQueryable, string[], string> CacheKeyFactory { get; set; }
@@ -347,7 +352,42 @@ public static void ExpireAll()
                 Cache.Remove(item);
             }
         }
+#else 
+	    /// <summary>Expire all cached objects && tag.</summary>
+        public static void ExpireAll()
+	    {
+		    var tags =  CacheTags.Select(x => x.Key).ToList();
+
+            // We do not use ExpireTag because type doesn't have CachePrefix
+            foreach (var tag in tags)
+		    {
+			     List<string> list;
+			     if (CacheTags.TryRemove(tag, out list))
+			     {
+				     // never lock something related to this list elsewhere or ensure we don't create a deadlock
+				     lock (list)
+				     {
+					     foreach (var item in list)
+					     {
+						     Cache.Remove(item);
+					     }
+				     }
+			     }
+		     }
+        }
 #endif
+        /// <summary>Expire type.</summary>
+        /// <param name="type">The type.</param>
+	    public static void ExpireType(Type type)
+	    {
+		    ExpireTag(type.Name + CacheTypeSuffix);
+	    }
+
+        /// <summary>Expire type.</summary>
+        public static void ExpireType<T>()
+        {
+            ExpireType(typeof(T));
+        }
 
         /// <summary>Expire all cached keys linked to specified tags.</summary>
         /// <param name="tags">
@@ -371,7 +411,7 @@ public static void ExpireTag(params string[] tags)
                     }
                 }
             }
-        }
+        } 
 
         /// <summary>Gets cached keys used to cache or retrieve a query from the QueryCacheManager.</summary>
         /// <param name="query">The query to cache or retrieve from the QueryCacheManager.</param>
diff --git a/src/shared/Z.EF.Plus.QueryCache.Shared/Z.EF.Plus.QueryCache.Shared.projitems b/src/shared/Z.EF.Plus.QueryCache.Shared/Z.EF.Plus.QueryCache.Shared.projitems
@@ -16,6 +16,7 @@
     <Import_RootNamespace>Z.EF.Plus.QueryCache.Shared</Import_RootNamespace>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)Extensions\DbSet\ExpireType.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\DbRawSqlQuery\FromCache.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\DbSqlQuery\FromCache.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\IQueryable`\FromCache.cs" />
diff --git a/src/shared/Z.EF.Plus.QueryDeferred.Shared/QueryDeferred.cs b/src/shared/Z.EF.Plus.QueryDeferred.Shared/QueryDeferred.cs
@@ -20,6 +20,7 @@
 using System.Data.Entity.Infrastructure;
 
 #elif EFCORE
+using Microsoft.EntityFrameworkCore.Query;
 using Microsoft.EntityFrameworkCore.Query.Internal;
 
 #endif
diff --git a/src/shared/Z.EF.Plus.QueryFuture.Shared/QueryFutureBatch.cs b/src/shared/Z.EF.Plus.QueryFuture.Shared/QueryFutureBatch.cs
@@ -403,23 +403,33 @@ protected DbCommand CreateCommandCombined()
                 var queryCommand = query.CreateExecutorAndGetCommand(out queryContext);
                 var sql = queryCommand.CommandText;
                 var parameters = queryCommand.Parameters;
+                string invariantName = null;
 
                 if (parameters.Count == 1 && parameters[0] is CompositeRelationalParameter compositeRelationalParameter)
                 {
+	                invariantName = parameters[0].InvariantName;
                     parameters = compositeRelationalParameter.RelationalParameters;
                 }
 
+                int i = 0;
+                object value;
                 // UPDATE parameter name
                 foreach (var relationalParameter in parameters)
                 {
-                    var parameter = queryContext.ParameterValues[relationalParameter.InvariantName];
+                    value = null;
+                    var parameter = queryContext.ParameterValues[invariantName ?? relationalParameter.InvariantName];
+                    if (invariantName != null && parameter is object[] objectArray)
+                    {
+	                    value = objectArray[i];
+	                    i++;
+                    }
 
                     var oldValue = relationalParameter.InvariantName;
                     var newValue = string.Concat("Z_", queryCount, "_", oldValue);
 
                     // CREATE parameter
                     var dbParameter = command.CreateParameter();
-                    dbParameter.CopyFrom(relationalParameter, parameter, newValue);
+                    dbParameter.CopyFrom(relationalParameter, value ?? parameter, newValue);
 
                     command.Parameters.Add(dbParameter);
 
diff --git a/src/shared/Z.EF.Plus.QueryIncludeFilterCore.Shared/QueryIncludeFilterProvider.cs b/src/shared/Z.EF.Plus.QueryIncludeFilterCore.Shared/QueryIncludeFilterProvider.cs
@@ -14,6 +14,7 @@
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Internal;
+using Microsoft.EntityFrameworkCore.Query;
 using Microsoft.EntityFrameworkCore.Query.Internal;
 
 #if EFCORE_2X
diff --git a/src/shared/Z.EF.Plus.QueryIncludeOptimized.Shared/QueryIncludeOptimizedProvider.cs b/src/shared/Z.EF.Plus.QueryIncludeOptimized.Shared/QueryIncludeOptimizedProvider.cs

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,8 @@ public static IEnumerable<T> FromCache<T>(this DbRawSqlQuery<T> query, CacheItem`
`51`	`51`	`{`
`52`	`52`	`item = query.ToList();`
`53`	`53`	`item = QueryCacheManager.AddOrGetExisting(key, item, policy) ?? item;`
`54`		`- QueryCacheManager.AddCacheTag(handler, key, tags);`
	`54`	`+ QueryCacheManager.AddCacheTag(handler, key, tags);`
	`55`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`55`	`56`	`}`
`56`	`57`	`}`
`57`	`58`
`@@ -85,6 +86,7 @@ public static IEnumerable<T> FromCache<T>(this DbRawSqlQuery<T> query, DateTimeO`
`85`	`86`	`item = query.ToList();`
`86`	`87`	`item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;`
`87`	`88`	`QueryCacheManager.AddCacheTag(handler, key, tags);`
	`89`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`88`	`90`	`}`
`89`	`91`	`}`
`90`	`92`
Original file line number	Diff line number	Diff line change
`@@ -52,6 +52,7 @@ public static IEnumerable<T> FromCache<T>(this DbSqlQuery<T> query, CacheItemPol`
`52`	`52`	`item = query.AsNoTracking().ToList();`
`53`	`53`	`item = QueryCacheManager.AddOrGetExisting(key, item, policy) ?? item;`
`54`	`54`	`QueryCacheManager.AddCacheTag(handler, key, tags);`
	`55`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`55`	`56`	`}`
`56`	`57`	`}`
`57`	`58`
`@@ -85,6 +86,7 @@ public static IEnumerable<T> FromCache<T>(this DbSqlQuery<T> query, DateTimeOffs`
`85`	`86`	`item = query.AsNoTracking().ToList();`
`86`	`87`	`item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;`
`87`	`88`	`QueryCacheManager.AddCacheTag(handler, key, tags);`
	`89`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`88`	`90`	`}`
`89`	`91`	`}`
`90`	`92`
Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,7 @@ public static Task<IEnumerable<T>> FromCacheAsync<T>(this IQueryable<T> query, C`
`58`	`58`	`item = query.AsNoTracking().ToList();`
`59`	`59`	`item = QueryCacheManager.AddOrGetExisting(key, item, policy) ?? item;`
`60`	`60`	`QueryCacheManager.AddCacheTag(key, tags);`
	`61`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`61`	`62`	`}`
`62`	`63`
`63`	`64`	`return (IEnumerable<T>) item;`
`@@ -98,6 +99,7 @@ public static Task<IEnumerable<T>> FromCacheAsync<T>(this IQueryable<T> query, D`
`98`	`99`	`item = query.AsNoTracking().ToList();`
`99`	`100`	`item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;`
`100`	`101`	`QueryCacheManager.AddCacheTag(key, tags);`
	`102`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`101`	`103`	`}`
`102`	`104`
`103`	`105`	`return (IEnumerable<T>) item;`
`@@ -153,6 +155,7 @@ public static Task<IEnumerable<T>> FromCacheAsync<T>(this IQueryable<T> query, p`
`153`	`155`	`item = await query.AsNoTracking().ToListAsync(cancellationToken).ConfigureAwait(false);`
`154`	`156`	`item = QueryCacheManager.AddOrGetExisting(key, item, policy) ?? item;`
`155`	`157`	`QueryCacheManager.AddCacheTag(handler, key, tags);`
	`158`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`156`	`159`	`}`
`157`	`160`	`}`
`158`	`161`
`@@ -207,6 +210,7 @@ public static Task<IEnumerable<T>> FromCacheAsync<T>(this IQueryable<T> query, C`
`207`	`210`	`item = await query.AsNoTracking().ToListAsync(cancellationToken).ConfigureAwait(false);`
`208`	`211`	`item = QueryCacheManager.AddOrGetExisting(key, item, absoluteExpiration) ?? item;`
`209`	`212`	`QueryCacheManager.AddCacheTag(handler, key, tags);`
	`213`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`210`	`214`	`}`
`211`	`215`	`}`
`212`	`216`
`@@ -291,6 +295,7 @@ public static Task<IEnumerable<T>> FromCacheAsync<T>(this IQueryable<T> query, p`
`291`	`295`	`item = await query.AsNoTracking().ToListAsync(cancellationToken).ConfigureAwait(false);`
`292`	`296`	`item = QueryCacheManager.Cache.Set(key, item, options);`
`293`	`297`	`QueryCacheManager.AddCacheTag(key, tags);`
	`298`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`294`	`299`	`}`
`295`	`300`
`296`	`301`	`item = item.IfDbNullThenNull();`
Original file line number	Diff line number	Diff line change
`@@ -52,12 +52,14 @@ public static T FromCache<T>(this QueryDeferred<T> query, CacheItemPolicy policy`
`52`	`52`
`53`	`53`	`item = QueryCacheManager.AddOrGetExistingDeferred<T>(key, item ?? DBNull.Value, policy) ?? item;`
`54`	`54`	`QueryCacheManager.AddCacheTag(handler, key, tags);`
	`55`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`55`	`56`	`}`
`56`	`57`	`#else`
`57`	`58`	`item = query.Execute();`
`58`	`59`
`59`	`60`	`item = QueryCacheManager.AddOrGetExistingDeferred<T>(key, item ?? DBNull.Value, policy) ?? item;`
`60`	`61`	`QueryCacheManager.AddCacheTag(key, tags);`
	`62`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`61`	`63`	`#endif`
`62`	`64`	`}`
`63`	`65`
`@@ -98,12 +100,14 @@ public static T FromCache<T>(this QueryDeferred<T> query, DateTimeOffset absolut`
`98`	`100`
`99`	`101`	`item = QueryCacheManager.AddOrGetExistingDeferred<T>(key, item ?? DBNull.Value, absoluteExpiration) ?? item;`
`100`	`102`	`QueryCacheManager.AddCacheTag(handler, key, tags);`
	`103`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`101`	`104`	`}`
`102`	`105`	`#else`
`103`	`106`	`item = query.Execute();`
`104`	`107`
`105`	`108`	`item = QueryCacheManager.AddOrGetExistingDeferred<T>(key, item ?? DBNull.Value, absoluteExpiration) ?? item;`
`106`	`109`	`QueryCacheManager.AddCacheTag(key, tags);`
	`110`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`107`	`111`	`#endif`
`108`	`112`	`}`
`109`	`113`
`@@ -156,6 +160,7 @@ public static T FromCache<T>(this QueryDeferred<T> query, MemoryCacheEntryOption`
`156`	`160`
`157`	`161`	`item = QueryCacheManager.Cache.Set(key, item ?? DBNull.Value, options);`
`158`	`162`	`QueryCacheManager.AddCacheTag(key, tags);`
	`163`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`159`	`164`	`}`
`160`	`165`
`161`	`166`	`item = item.IfDbNullThenNull();`
Original file line number	Diff line number	Diff line change
`@@ -56,6 +56,7 @@ public static Task<T> FromCacheAsync<T>(this QueryDeferred<T> query, CacheItemPo`
`56`	`56`	`item = query.Execute();`
`57`	`57`	`item = QueryCacheManager.AddOrGetExistingDeferred<T>(key, item ?? DBNull.Value, policy) ?? item;`
`58`	`58`	`QueryCacheManager.AddCacheTag(key, tags);`
	`59`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`59`	`60`	`}`
`60`	`61`
`61`	`62`	`item = item.IfDbNullThenNull();`
`@@ -99,6 +100,7 @@ public static Task<T> FromCacheAsync<T>(this QueryDeferred<T> query, DateTimeOff`
`99`	`100`	`item = query.Execute();`
`100`	`101`	`item = QueryCacheManager.AddOrGetExistingDeferred<T>(key, item ?? DBNull.Value, absoluteExpiration) ?? item;`
`101`	`102`	`QueryCacheManager.AddCacheTag(key, tags);`
	`103`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`102`	`104`	`}`
`103`	`105`
`104`	`106`	`item = item.IfDbNullThenNull();`
`@@ -156,6 +158,7 @@ public static Task<T> FromCacheAsync<T>(this QueryDeferred<T> query, params stri`
`156`	`158`	`item = await query.ExecuteAsync(cancellationToken).ConfigureAwait(false);`
`157`	`159`	`item = QueryCacheManager.AddOrGetExistingDeferred<T>(key, item ?? DBNull.Value, policy) ?? item;`
`158`	`160`	`QueryCacheManager.AddCacheTag(handler, key, tags);`
	`161`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`159`	`162`	`}`
`160`	`163`	`}`
`161`	`164`
`@@ -212,6 +215,7 @@ public static Task<T> FromCacheAsync<T>(this QueryDeferred<T> query, CacheItemPo`
`212`	`215`	`item = await query.ExecuteAsync(cancellationToken).ConfigureAwait(false);`
`213`	`216`	`item = QueryCacheManager.AddOrGetExistingDeferred<T>(key, item ?? DBNull.Value, absoluteExpiration) ?? item;`
`214`	`217`	`QueryCacheManager.AddCacheTag(handler, key, tags);`
	`218`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`215`	`219`	`}`
`216`	`220`	`}`
`217`	`221`
`@@ -298,6 +302,7 @@ public static Task<T> FromCacheAsync<T>(this QueryDeferred<T> query, params stri`
`298`	`302`	`item = await query.ExecuteAsync(cancellationToken).ConfigureAwait(false);`
`299`	`303`	`item = QueryCacheManager.Cache.Set(key, item ?? DBNull.Value, options);`
`300`	`304`	`QueryCacheManager.AddCacheTag(key, tags);`
	`305`	`+ QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix);`
`301`	`306`	`}`
`302`	`307`
`303`	`308`	`item = item.IfDbNullThenNull();`