Feedback

Author: JunTaoLuo

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

@@ -10,7 +10,6 @@ namespace Microsoft.AspNetCore.ResponseCaching.Internal
     internal static class DefaultResponseCacheSerializer
     {
         private const int FormatVersion = 1;
-        private const string RoundTripFormat = "o";
 
         public static object Deserialize(byte[] serializedEntry)
         {

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

@@ -43,44 +43,21 @@ public void DisableBuffering()
 
         public override void SetLength(long value)
         {
-            try
-            {
-                _innerStream.SetLength(value);
-                if (BufferingEnabled)
-                {
-                    BufferedStream.SetLength(value);
-                }
-            }
-            catch
-            {
-                DisableBuffering();
-                throw;
-            }
+            DisableBuffering();
+            _innerStream.SetLength(value);
         }
 
         public override long Seek(long offset, SeekOrigin origin)
         {
-            try
-            {
-                var position = _innerStream.Seek(offset, origin);
-                if (BufferingEnabled)
-                {
-                    BufferedStream.Seek(offset, origin);
-                }
-                return position;
-            }
-            catch
-            {
-                DisableBuffering();
-                throw;
-            }
+            DisableBuffering();
+            return _innerStream.Seek(offset, origin);
         }
 
         public override void Flush()
             => _innerStream.Flush();
 
-        public override async Task FlushAsync(CancellationToken cancellationToken)
-            => await _innerStream.FlushAsync();
+        public override Task FlushAsync(CancellationToken cancellationToken)
+            => _innerStream.FlushAsync();
 
         // Underlying stream is write-only, no need to override other read related methods
         public override int Read(byte[] buffer, int offset, int count)
@@ -91,50 +68,53 @@ public override void Write(byte[] buffer, int offset, int count)
             try
             {
                 _innerStream.Write(buffer, offset, count);
-                if (BufferingEnabled)
-                {
-                    BufferedStream.Write(buffer, offset, count);
-                }
             }
             catch
             {
                 DisableBuffering();
                 throw;
             }
+
+            if (BufferingEnabled)
+            {
+                BufferedStream.Write(buffer, offset, count);
+            }
         }
 
         public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
             try
             {
                 await _innerStream.WriteAsync(buffer, offset, count, cancellationToken);
-                if (BufferingEnabled)
-                {
-                    await BufferedStream.WriteAsync(buffer, offset, count, cancellationToken);
-                }
             }
             catch
             {
                 DisableBuffering();
                 throw;
             }
+
+            if (BufferingEnabled)
+            {
+                await BufferedStream.WriteAsync(buffer, offset, count, cancellationToken);
+            }
         }
 
         public override void WriteByte(byte value)
         {
             try
             {
                 _innerStream.WriteByte(value);
-                if (BufferingEnabled)
-                {
-                    BufferedStream.WriteByte(value);
-                }
             }
             catch
             {
                 DisableBuffering();
                 throw;
             }
+
+            if (BufferingEnabled)
+            {
+                BufferedStream.WriteByte(value);
+            }
         }
 
 #if NETSTANDARD1_3

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

@@ -19,10 +19,10 @@ public SendFileFeatureWrapper(IHttpSendFileFeature originalSendFileFeature, Resp
         }
 
         // Flush and disable the buffer if anyone tries to call the SendFile feature.
-        public async Task SendFileAsync(string path, long offset, long? length, CancellationToken cancellation)
+        public Task SendFileAsync(string path, long offset, long? length, CancellationToken cancellation)
         {
             _responseCacheStream.DisableBuffering();
-            await _originalSendFileFeature.SendFileAsync(path, offset, length, cancellation);
+            return _originalSendFileFeature.SendFileAsync(path, offset, length, cancellation);
         }
     }
 }

src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingContext.cs

@@ -183,7 +183,7 @@ private string CreateVaryByCacheKey(CachedVaryBy varyBy)
             return builder.ToString();
         }
 
-        public bool RequestIsCacheable()
+        internal bool RequestIsCacheable()
         {
             // Verify the method
             // TODO: RFC lists POST as a cacheable method when explicit freshness information is provided, but this is not widely implemented. Will revisit.
@@ -387,6 +387,10 @@ internal async Task<bool> TryServeFromCacheAsync()
 
                         responseServed = true;
                     }
+                    else
+                    {
+                        throw new InvalidOperationException("Response type not specified or is unrecognized.");
+                    }
                 }
                 else
                 {
@@ -396,7 +400,6 @@ internal async Task<bool> TryServeFromCacheAsync()
 
             if (!responseServed && RequestCacheControl.OnlyIfCached)
             {
-                HttpContext.Response.Clear();
                 HttpContext.Response.StatusCode = StatusCodes.Status504GatewayTimeout;
 
                 responseServed = true;
@@ -467,7 +470,6 @@ internal void FinalizeCachingBody()
             {
                 _cachedResponse.Body = ResponseCacheStream.BufferedStream.ToArray();
 
-                // TODO: Timeouts
                 Cache.Set(_cacheKey, _cachedResponse, _cachedResponseValidFor);
             }
         }