Update ResponseCache to handle VaryBy rules

Author: JunTaoLuo

samples/ResponseCachingSample/Startup.cs

@@ -20,14 +20,18 @@ public void ConfigureServices(IServiceCollection services)
 
         public void Configure(IApplicationBuilder app)
         {
+            app.UseDeveloperExceptionPage();
             app.UseResponseCaching();
             app.Run(async (context) =>
             {
+                // These settings should be configured by context.Response.Cache.*
                 context.Response.GetTypedHeaders().CacheControl = new CacheControlHeaderValue()
                 {
                     Public = true,
                     MaxAge = TimeSpan.FromSeconds(10)                    
                 };
+                context.Response.GetTypedHeaders().Append("Vary", "Accept-Language");
+
                 await context.Response.WriteAsync("Hello World! " + DateTime.UtcNow);
             });
         }

samples/ResponseCachingSample/project.json

@@ -1,6 +1,7 @@
 {
   "version": "1.1.0-*",
   "dependencies": {
+    "Microsoft.AspNetCore.Diagnostics": "0.1.0-*",
     "Microsoft.AspNetCore.ResponseCaching": "0.1.0-*",
     "Microsoft.AspNetCore.Server.IISIntegration": "1.1.0-*",
     "Microsoft.AspNetCore.Server.Kestrel": "1.1.0-*",

src/Microsoft.AspNetCore.ResponseCaching/ResponseCache/ResponseCacheEntry.cs renamed to src/Microsoft.AspNetCore.ResponseCaching/ResponseCache/CachedResponse.cs

@@ -5,10 +5,16 @@
 
 namespace Microsoft.AspNetCore.ResponseCaching
 {
-    public class ResponseCacheEntry
+    public class CachedResponse : IResponseCacheEntry
     {
+        public string Key { get; set; }
+
+        public ResponseCacheEntryType Type => ResponseCacheEntryType.Response;
+
         public int StatusCode { get; set; }
+
         internal IHeaderDictionary Headers { get; set; } = new HeaderDictionary();
+
         internal byte[] Body { get; set; }
     }
 }

src/Microsoft.AspNetCore.ResponseCaching/ResponseCache/CachedVaryBy.cs

@@ -0,0 +1,16 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.AspNetCore.ResponseCaching
+{
+    public class CachedVaryBy : IResponseCacheEntry
+    {
+        public string Key { get; set; }
+
+        public ResponseCacheEntryType Type => ResponseCacheEntryType.VaryBy;
+
+        public string[] Headers { get; set; }
+
+        public string[] Params { get; set; }
+    }
+}

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

@@ -11,7 +11,7 @@ public static class DefaultResponseCacheSerializer
     {
         private const int FormatVersion = 1;
 
-        public static ResponseCacheEntry Deserialize(byte[] serializedEntry)
+        public static IResponseCacheEntry Deserialize(byte[] serializedEntry)
         {
             using (var memory = new MemoryStream(serializedEntry))
             {
@@ -22,19 +22,20 @@ public static ResponseCacheEntry Deserialize(byte[] serializedEntry)
             }
         }
 
-        public static byte[] Serialize(ResponseCacheEntry entry)
+        public static byte[] Serialize(IResponseCacheEntry entry)
         {
             using (var memory = new MemoryStream())
             {
                 using (var writer = new BinaryWriter(memory))
                 {
                     Write(writer, entry);
+                    writer.Flush();
                     return memory.ToArray();
                 }
             }
         }
 
-        public static ResponseCacheEntry Read(BinaryReader reader)
+        public static IResponseCacheEntry Read(BinaryReader reader)
         {
             if (reader == null)
             {
@@ -46,6 +47,28 @@ public static ResponseCacheEntry Read(BinaryReader reader)
                 return null;
             }
 
+            var key = reader.ReadString();
+            var type = (ResponseCacheEntryType)reader.ReadInt32();
+
+            if (type == ResponseCacheEntryType.Response)
+            {
+                var cachedResponse = ReadCachedResponse(reader);
+                cachedResponse.Key = key;
+                return cachedResponse;
+            }
+            else if (type == ResponseCacheEntryType.VaryBy)
+            {
+                var cachedResponse = ReadCachedVaryBy(reader);
+                cachedResponse.Key = key;
+                return cachedResponse;
+            }
+
+            // Unable to read as CachedResponse or CachedVaryBy
+            return null;
+        }
+
+        private static IResponseCacheEntry ReadCachedResponse(BinaryReader reader)
+        {
             var statusCode = reader.ReadInt32();
             var headerCount = reader.ReadInt32();
             var headers = new HeaderDictionary();
@@ -58,9 +81,31 @@ public static ResponseCacheEntry Read(BinaryReader reader)
             var bodyLength = reader.ReadInt32();
             var body = reader.ReadBytes(bodyLength);
 
-            return new ResponseCacheEntry { StatusCode = statusCode, Headers = headers, Body = body };
+            return new CachedResponse { StatusCode = statusCode, Headers = headers, Body = body };
         }
-        public static void Write(BinaryWriter writer, ResponseCacheEntry entry)
+
+        private static IResponseCacheEntry ReadCachedVaryBy(BinaryReader reader)
+        {
+            var headerCount = reader.ReadInt32();
+            var headerArray = new string[headerCount];
+            for (var index = 0; index < headerCount; index++)
+            {
+                var value = reader.ReadString();
+                headerArray[index] = value;
+            }
+
+            var paramCount = reader.ReadInt32();
+            var paramArray = new string[paramCount];
+            for (var index = 0; index < paramCount; index++)
+            {
+                var value = reader.ReadString();
+                paramArray[index] = value;
+            }
+
+            return new CachedVaryBy { Headers = headerArray, Params = paramArray };
+        }
+
+        public static void Write(BinaryWriter writer, IResponseCacheEntry entry)
         {
             if (writer == null)
             {
@@ -73,9 +118,23 @@ public static void Write(BinaryWriter writer, ResponseCacheEntry entry)
             }
 
             writer.Write(FormatVersion);
+            writer.Write(entry.Key);
+            writer.Write((int)entry.Type);
+            
+            if (entry is CachedResponse)
+            {
+                WriteCachedResponse(writer, entry as CachedResponse);
+            }
+            else if (entry is CachedVaryBy)
+            {
+                WriteCachedVaryBy(writer, entry as CachedVaryBy);
+            }
+        }
+
+        private static void WriteCachedResponse(BinaryWriter writer, CachedResponse entry)
+        {
             writer.Write(entry.StatusCode);
             writer.Write(entry.Headers.Count);
-
             foreach (var header in entry.Headers)
             {
                 writer.Write(header.Key);
@@ -85,5 +144,33 @@ public static void Write(BinaryWriter writer, ResponseCacheEntry entry)
             writer.Write(entry.Body.Length);
             writer.Write(entry.Body);
         }
+
+        private static void WriteCachedVaryBy(BinaryWriter writer, CachedVaryBy entry)
+        {
+            if (entry.Headers == null)
+            {
+                writer.Write(0);
+            }
+            else
+            {
+                writer.Write(entry.Headers.Length);
+                foreach (var header in entry.Headers)
+                {
+                    writer.Write(header);
+                }
+            }
+            if (entry.Params == null)
+            {
+                writer.Write(0);
+            }
+            else
+            {
+                writer.Write(entry.Params.Length);
+                foreach (var param in entry.Params)
+                {
+                    writer.Write(param);
+                }
+            }
+        }
     }
 }

src/Microsoft.AspNetCore.ResponseCaching/ResponseCache/DistributedResponseCache.cs

@@ -14,7 +14,7 @@ public DistributedResponseCache(IDistributedCache cache)
             _cache = cache;
         }
 
-        public ResponseCacheEntry Get(string key)
+        public IResponseCacheEntry Get(string key)
         {
             var serializedEntry = _cache.Get(key);
             if (serializedEntry != null)
@@ -32,7 +32,7 @@ public void Remove(string key)
             _cache.Remove(key);
         }
 
-        public void Set(string key, ResponseCacheEntry entry)
+        public void Set(string key, IResponseCacheEntry entry)
         {
             _cache.Set(key, DefaultResponseCacheSerializer.Serialize(entry));
         }

src/Microsoft.AspNetCore.ResponseCaching/ResponseCache/IResponseCache.cs

@@ -5,8 +5,8 @@ namespace Microsoft.AspNetCore.ResponseCaching
 {
     public interface IResponseCache
     {
-        ResponseCacheEntry Get(string key);
-        void Set(string key, ResponseCacheEntry entry);
+        IResponseCacheEntry Get(string key);
+        void Set(string key, IResponseCacheEntry entry);
         void Remove(string key);
     }
 }

src/Microsoft.AspNetCore.ResponseCaching/ResponseCache/IResponseCacheEntry.cs

@@ -0,0 +1,11 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.AspNetCore.ResponseCaching
+{
+    public interface IResponseCacheEntry
+    {
+        string Key { get; set; }
+        ResponseCacheEntryType Type { get; }
+    }
+}

src/Microsoft.AspNetCore.ResponseCaching/ResponseCache/MemoryResponseCache.cs

@@ -14,17 +14,17 @@ public MemoryResponseCache(IMemoryCache cache)
             _cache = cache;
         }
 
-        public ResponseCacheEntry Get(string key)
+        public IResponseCacheEntry Get(string key)
         {
-            return _cache.Get<ResponseCacheEntry>(key);
+            return _cache.Get<IResponseCacheEntry>(key);
         }
 
         public void Remove(string key)
         {
             _cache.Remove(key);
         }
 
-        public void Set(string key, ResponseCacheEntry entry)
+        public void Set(string key, IResponseCacheEntry entry)
         {
             _cache.Set(key, entry);
         }

src/Microsoft.AspNetCore.ResponseCaching/ResponseCache/ResponseCacheEntryType.cs

@@ -0,0 +1,11 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.AspNetCore.ResponseCaching
+{
+    public enum ResponseCacheEntryType
+    {
+        Response = 0,
+        VaryBy = 1
+    }
+}