Feedback

Author: JunTaoLuo

src/Microsoft.AspNetCore.ResponseCaching/Internal/DefaultResponseCacheEntrySerializer.cs

@@ -103,9 +103,17 @@ private static CachedResponse ReadCachedResponse(BinaryReader reader)
         private static CachedVaryBy ReadCachedVaryBy(BinaryReader reader)
         {
             var headerCount = reader.ReadInt32();
-            var headers = headerCount > 0 ? reader.ReadString().Split(',') : null;
+            var headers = new string[headerCount];
+            for (var index = 0; index < headerCount; index++)
+            {
+                headers[index] = reader.ReadString();
+            }
             var paramCount = reader.ReadInt32();
-            var param = paramCount > 0 ? reader.ReadString().Split(',') : null;
+            var param = new string[paramCount];
+            for (var index = 0; index < paramCount; index++)
+            {
+                param[index] = reader.ReadString();
+            }
 
             return new CachedVaryBy { Headers = headers, Params = param };
         }
@@ -162,15 +170,15 @@ private static void WriteCachedVaryBy(BinaryWriter writer, CachedVaryBy entry)
             writer.Write(nameof(CachedVaryBy));
 
             writer.Write(entry.Headers.Count);
-            if (entry.Headers.Count > 0)
+            foreach (var header in entry.Headers)
             {
-                writer.Write(entry.Headers);
+                writer.Write(header);
             }
 
             writer.Write(entry.Params.Count);
-            if (entry.Params.Count > 0)
+            foreach (var param in entry.Params)
             {
-                writer.Write(entry.Params);
+                writer.Write(param);
             }
         }
     }

src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingContext.cs

@@ -20,7 +20,8 @@ namespace Microsoft.AspNetCore.ResponseCaching
     internal class ResponseCachingContext
     {
         private static readonly CacheControlHeaderValue EmptyCacheControl = new CacheControlHeaderValue();
-        private static readonly char KeyDelimiter = '\x1e'; // Use the record separator for delimiting components of the cache key
+        // Use the record separator for delimiting components of the cache key to avoid possible collisions
+        private static readonly char KeyDelimiter = '\x1e';
 
         private readonly HttpContext _httpContext;
         private readonly IResponseCache _cache;
@@ -161,7 +162,7 @@ internal string CreateCacheKey(CachedVaryBy varyBy)
                 // Vary by headers
                 if (varyBy?.Headers.Count > 0)
                 {
-                    // Append a value denoting the start of the header segment of the cache key
+                    // Append a group separator for the header segment of the cache key
                     builder.Append(KeyDelimiter)
                         .Append('H');
 
@@ -187,7 +188,7 @@ internal string CreateCacheKey(CachedVaryBy varyBy)
                 // Vary by query params
                 if (varyBy?.Params.Count > 0)
                 {
-                    // Append a value denoting the start of the query parameter segment of the cache key
+                    // Append a group separator for the query parameter segment of the cache key
                     builder.Append(KeyDelimiter)
                         .Append('Q');
 
@@ -197,7 +198,7 @@ internal string CreateCacheKey(CachedVaryBy varyBy)
                         foreach (var query in _httpContext.Request.Query.OrderBy(q => q.Key))
                         {
                             builder.Append(KeyDelimiter)
-                                .Append(query.Key.ToLower())
+                                .Append(query.Key.ToUpperInvariant())
                                 .Append("=")
                                 .Append(query.Value);
                         }
@@ -228,7 +229,7 @@ internal string CreateCacheKey(CachedVaryBy varyBy)
                 var customKey = _cacheKeySuffixProvider.CreateCustomKeySuffix(_httpContext);
                 if (!string.IsNullOrEmpty(customKey))
                 {
-                    // Append a value denoting the start of the query parameter segment of the cache key
+                    // Append a group separator for the custom segment of the cache key
                     builder.Append(KeyDelimiter)
                         .Append('C');
 

src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingOptionsFeature.cs renamed to src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingFeature.cs

@@ -6,8 +6,8 @@
 namespace Microsoft.AspNetCore.ResponseCaching
 {
     // TODO: Temporary interface for endpoints to specify options for response caching
-    public class ResponseCachingOptionsFeature
+    public class ResponseCachingFeature
     {
-        public StringValues Params;
+        public StringValues Params { get; set; }
     }
 }

src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingHttpContextExtensions.cs

@@ -10,17 +10,17 @@ public static class ResponseCachingHttpContextExtensions
     {
         public static void AddResponseCachingOptions(this HttpContext httpContext)
         {
-            httpContext.Features.Set(new ResponseCachingOptionsFeature());
+            httpContext.Features.Set(new ResponseCachingFeature());
         }
 
         public static void RemoveResponseCachingOptions(this HttpContext httpContext)
         {
-            httpContext.Features.Set<ResponseCachingOptionsFeature>(null);
+            httpContext.Features.Set<ResponseCachingFeature>(null);
         }
 
-        public static ResponseCachingOptionsFeature GetResponseCachingOptions(this HttpContext httpContext)
+        public static ResponseCachingFeature GetResponseCachingOptions(this HttpContext httpContext)
         {
-            return httpContext.Features.Get<ResponseCachingOptionsFeature>() ?? new ResponseCachingOptionsFeature();
+            return httpContext.Features.Get<ResponseCachingFeature>() ?? new ResponseCachingFeature();
         }
     }
 }

test/Microsoft.AspNetCore.ResponseCaching.Tests/ResponseCachingContextTests.cs

@@ -233,7 +233,7 @@ public void CreateCacheKey_Includes_AllQueryParamsGivenAsterisk()
 
             // To support case insensitivity, all param keys are converted to lower case.
             // Explicit VaryBy uses the casing specified in the setting.
-            Assert.Equal($"GET{KeyDelimiter}/{KeyDelimiter}Q{KeyDelimiter}parama=ValueA{KeyDelimiter}paramb=ValueB", context.CreateCacheKey(new CachedVaryBy()
+            Assert.Equal($"GET{KeyDelimiter}/{KeyDelimiter}Q{KeyDelimiter}PARAMA=ValueA{KeyDelimiter}PARAMB=ValueB", context.CreateCacheKey(new CachedVaryBy()
             {
                 Params = new string[] { "*" }
             }));