Merge branch 'rel/1.0.0' into rel/1.0.0-preview1

Author: JunTaoLuo

samples/ResponseCachingSample/Startup.cs

@@ -15,12 +15,12 @@ public class Startup
     {
         public void ConfigureServices(IServiceCollection services)
         {
-            services.AddMemoryResponseCacheStore();
+            services.AddResponseCaching();
         }
 
         public void Configure(IApplicationBuilder app)
         {
-            app.UseResponseCache();
+            app.UseResponseCaching();
             app.Run(async (context) =>
             {
                 context.Response.GetTypedHeaders().CacheControl = new CacheControlHeaderValue()

src/Microsoft.AspNetCore.ResponseCaching.Abstractions/IResponseCacheFeature.cs renamed to src/Microsoft.AspNetCore.ResponseCaching.Abstractions/IResponseCachingFeature.cs

@@ -1,18 +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.
 
-using Microsoft.Extensions.Primitives;
-
 namespace Microsoft.AspNetCore.ResponseCaching
 {
     /// <summary>
     /// A feature for configuring additional response cache options on the HTTP response.
     /// </summary>
-    public interface IResponseCacheFeature
+    public interface IResponseCachingFeature
     {
         /// <summary>
         /// Gets or sets the query keys used by the response cache middleware for calculating secondary vary keys.
         /// </summary>
-        StringValues VaryByQueryKeys { get; set; }
+        string[] VaryByQueryKeys { get; set; }
     }
 }

src/Microsoft.AspNetCore.ResponseCaching/Internal/Interfaces/IResponseCacheStore.cs renamed to src/Microsoft.AspNetCore.ResponseCaching/Internal/Interfaces/IResponseCache.cs

@@ -6,7 +6,7 @@
 
 namespace Microsoft.AspNetCore.ResponseCaching.Internal
 {
-    public interface IResponseCacheStore
+    public interface IResponseCache
     {
         Task<IResponseCacheEntry> GetAsync(string key);
         Task SetAsync(string key, IResponseCacheEntry entry, TimeSpan validFor);

src/Microsoft.AspNetCore.ResponseCaching/Internal/Interfaces/IResponseCacheKeyProvider.cs renamed to src/Microsoft.AspNetCore.ResponseCaching/Internal/Interfaces/IResponseCachingKeyProvider.cs

@@ -5,27 +5,27 @@
 
 namespace Microsoft.AspNetCore.ResponseCaching.Internal
 {
-    public interface IResponseCacheKeyProvider
+    public interface IResponseCachingKeyProvider
     {
         /// <summary>
         /// Create a base key for a response cache entry.
         /// </summary>
-        /// <param name="context">The <see cref="ResponseCacheContext"/>.</param>
+        /// <param name="context">The <see cref="ResponseCachingContext"/>.</param>
         /// <returns>The created base key.</returns>
-        string CreateBaseKey(ResponseCacheContext context);
+        string CreateBaseKey(ResponseCachingContext context);
 
         /// <summary>
         /// Create a vary key for storing cached responses.
         /// </summary>
-        /// <param name="context">The <see cref="ResponseCacheContext"/>.</param>
+        /// <param name="context">The <see cref="ResponseCachingContext"/>.</param>
         /// <returns>The created vary key.</returns>
-        string CreateStorageVaryByKey(ResponseCacheContext context);
+        string CreateStorageVaryByKey(ResponseCachingContext context);
 
         /// <summary>
         /// Create one or more vary keys for looking up cached responses.
         /// </summary>
-        /// <param name="context">The <see cref="ResponseCacheContext"/>.</param>
+        /// <param name="context">The <see cref="ResponseCachingContext"/>.</param>
         /// <returns>An ordered <see cref="IEnumerable{T}"/> containing the vary keys to try when looking up items.</returns>
-        IEnumerable<string> CreateLookupVaryByKeys(ResponseCacheContext context);
+        IEnumerable<string> CreateLookupVaryByKeys(ResponseCachingContext context);
     }
 }

src/Microsoft.AspNetCore.ResponseCaching/Internal/Interfaces/IResponseCachePolicyProvider.cs renamed to src/Microsoft.AspNetCore.ResponseCaching/Internal/Interfaces/IResponseCachingPolicyProvider.cs

@@ -3,27 +3,27 @@
 
 namespace Microsoft.AspNetCore.ResponseCaching.Internal
 {
-    public interface IResponseCachePolicyProvider
+    public interface IResponseCachingPolicyProvider
     {
         /// <summary>
         /// Determine wehther the response cache middleware should be executed for the incoming HTTP request.
         /// </summary>
-        /// <param name="context">The <see cref="ResponseCacheContext"/>.</param>
+        /// <param name="context">The <see cref="ResponseCachingContext"/>.</param>
         /// <returns><c>true</c> if the request is cacheable; otherwise <c>false</c>.</returns>
-        bool IsRequestCacheable(ResponseCacheContext context);
+        bool IsRequestCacheable(ResponseCachingContext context);
 
         /// <summary>
         /// Determine whether the response received by the middleware be cached for future requests.
         /// </summary>
-        /// <param name="context">The <see cref="ResponseCacheContext"/>.</param>
+        /// <param name="context">The <see cref="ResponseCachingContext"/>.</param>
         /// <returns><c>true</c> if the response is cacheable; otherwise <c>false</c>.</returns>
-        bool IsResponseCacheable(ResponseCacheContext context);
+        bool IsResponseCacheable(ResponseCachingContext context);
 
         /// <summary>
         /// Determine whether the response retrieved from the response cache is fresh and be served.
         /// </summary>
-        /// <param name="context">The <see cref="ResponseCacheContext"/>.</param>
+        /// <param name="context">The <see cref="ResponseCachingContext"/>.</param>
         /// <returns><c>true</c> if the cached entry is fresh; otherwise <c>false</c>.</returns>
-        bool IsCachedEntryFresh(ResponseCacheContext context);
+        bool IsCachedEntryFresh(ResponseCachingContext context);
     }
 }

src/Microsoft.AspNetCore.ResponseCaching/Internal/MemoryResponseCacheStore.cs renamed to src/Microsoft.AspNetCore.ResponseCaching/Internal/MemoryResponseCache.cs

@@ -7,11 +7,11 @@
 
 namespace Microsoft.AspNetCore.ResponseCaching.Internal
 {
-    public class MemoryResponseCacheStore : IResponseCacheStore
+    public class MemoryResponseCache : IResponseCache
     {
         private readonly IMemoryCache _cache;
 
-        public MemoryResponseCacheStore(IMemoryCache cache)
+        public MemoryResponseCache(IMemoryCache cache)
         {
             if (cache == null)
             {

src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCacheContext.cs renamed to src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCachingContext.cs

@@ -11,7 +11,7 @@
 
 namespace Microsoft.AspNetCore.ResponseCaching.Internal
 {
-    public class ResponseCacheContext
+    public class ResponseCachingContext
     {
         private static readonly CacheControlHeaderValue EmptyCacheControl = new CacheControlHeaderValue();
 
@@ -24,7 +24,7 @@ public class ResponseCacheContext
         private DateTimeOffset? _responseExpires;
         private bool _parsedResponseExpires;
 
-        internal ResponseCacheContext(HttpContext httpContext, ILogger logger)
+        internal ResponseCachingContext(HttpContext httpContext, ILogger logger)
         {
             HttpContext = httpContext;
             Logger = logger;
@@ -54,7 +54,7 @@ internal ResponseCacheContext(HttpContext httpContext, ILogger logger)
 
         internal Stream OriginalResponseStream { get; set; }
 
-        internal ResponseCacheStream ResponseCacheStream { get; set; }
+        internal ResponseCachingStream ResponseCachingStream { get; set; }
 
         internal IHttpSendFileFeature OriginalSendFileFeature { get; set; }
 

src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCacheKeyProvider.cs renamed to src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCachingKeyProvider.cs

@@ -5,23 +5,21 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.ResponseCaching.Internal;
 using Microsoft.Extensions.ObjectPool;
 using Microsoft.Extensions.Options;
 using Microsoft.Extensions.Primitives;
 
 namespace Microsoft.AspNetCore.ResponseCaching.Internal
 {
-    public class ResponseCacheKeyProvider : IResponseCacheKeyProvider
+    public class ResponseCachingKeyProvider : IResponseCachingKeyProvider
     {
         // Use the record separator for delimiting components of the cache key to avoid possible collisions
         private static readonly char KeyDelimiter = '\x1e';
 
         private readonly ObjectPool<StringBuilder> _builderPool;
-        private readonly ResponseCacheOptions _options;
+        private readonly ResponseCachingOptions _options;
 
-        public ResponseCacheKeyProvider(ObjectPoolProvider poolProvider, IOptions<ResponseCacheOptions> options)
+        public ResponseCachingKeyProvider(ObjectPoolProvider poolProvider, IOptions<ResponseCachingOptions> options)
         {
             if (poolProvider == null)
             {
@@ -36,13 +34,13 @@ public ResponseCacheKeyProvider(ObjectPoolProvider poolProvider, IOptions<Respon
             _options = options.Value;
         }
 
-        public IEnumerable<string> CreateLookupVaryByKeys(ResponseCacheContext context)
+        public IEnumerable<string> CreateLookupVaryByKeys(ResponseCachingContext context)
         {
             return new string[] { CreateStorageVaryByKey(context) };
         }
 
         // GET<delimiter>/PATH
-        public string CreateBaseKey(ResponseCacheContext context)
+        public string CreateBaseKey(ResponseCachingContext context)
         {
             if (context == null)
             {
@@ -76,7 +74,7 @@ public string CreateBaseKey(ResponseCacheContext context)
         }
 
         // BaseKey<delimiter>H<delimiter>HeaderName=HeaderValue<delimiter>Q<delimiter>QueryName=QueryValue
-        public string CreateStorageVaryByKey(ResponseCacheContext context)
+        public string CreateStorageVaryByKey(ResponseCachingContext context)
         {
             if (context == null)
             {
@@ -86,7 +84,7 @@ public string CreateStorageVaryByKey(ResponseCacheContext context)
             var varyByRules = context.CachedVaryByRules;
             if (varyByRules == null)
             {
-                throw new InvalidOperationException($"{nameof(CachedVaryByRules)} must not be null on the {nameof(ResponseCacheContext)}");
+                throw new InvalidOperationException($"{nameof(CachedVaryByRules)} must not be null on the {nameof(ResponseCachingContext)}");
             }
 
             if ((StringValues.IsNullOrEmpty(varyByRules.Headers) && StringValues.IsNullOrEmpty(varyByRules.QueryKeys)))

src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCachePolicyProvider.cs renamed to src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCachingPolicyProvider.cs

@@ -8,11 +8,11 @@
 
 namespace Microsoft.AspNetCore.ResponseCaching.Internal
 {
-    public class ResponseCachePolicyProvider : IResponseCachePolicyProvider
+    public class ResponseCachingPolicyProvider : IResponseCachingPolicyProvider
     {
         private static readonly CacheControlHeaderValue EmptyCacheControl = new CacheControlHeaderValue();
 
-        public virtual bool IsRequestCacheable(ResponseCacheContext context)
+        public virtual bool IsRequestCacheable(ResponseCachingContext context)
         {
             // Verify the method
             var request = context.HttpContext.Request;
@@ -55,7 +55,7 @@ public virtual bool IsRequestCacheable(ResponseCacheContext context)
             return true;
         }
 
-        public virtual bool IsResponseCacheable(ResponseCacheContext context)
+        public virtual bool IsResponseCacheable(ResponseCachingContext context)
         {
             // Only cache pages explicitly marked with public
             if (!context.ResponseCacheControlHeaderValue.Public)
@@ -155,7 +155,7 @@ public virtual bool IsResponseCacheable(ResponseCacheContext context)
             return true;
         }
 
-        public virtual bool IsCachedEntryFresh(ResponseCacheContext context)
+        public virtual bool IsCachedEntryFresh(ResponseCachingContext context)
         {
             var age = context.CachedEntryAge.Value;
             var cachedControlHeaders = context.CachedResponseHeaders.CacheControl ?? EmptyCacheControl;

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

@@ -10,18 +10,18 @@ namespace Microsoft.AspNetCore.ResponseCaching.Internal
     internal class SendFileFeatureWrapper : IHttpSendFileFeature
     {
         private readonly IHttpSendFileFeature _originalSendFileFeature;
-        private readonly ResponseCacheStream _responseCacheStream;
+        private readonly ResponseCachingStream _responseCachingStream;
 
-        public SendFileFeatureWrapper(IHttpSendFileFeature originalSendFileFeature, ResponseCacheStream responseCacheStream)
+        public SendFileFeatureWrapper(IHttpSendFileFeature originalSendFileFeature, ResponseCachingStream responseCachingStream)
         {
             _originalSendFileFeature = originalSendFileFeature;
-            _responseCacheStream = responseCacheStream;
+            _responseCachingStream = responseCachingStream;
         }
 
         // Flush and disable the buffer if anyone tries to call the SendFile feature.
         public Task SendFileAsync(string path, long offset, long? length, CancellationToken cancellation)
         {
-            _responseCacheStream.DisableBuffering();
+            _responseCachingStream.DisableBuffering();
             return _originalSendFileFeature.SendFileAsync(path, offset, length, cancellation);
         }
     }