fixing Nuget package build for the provider, fix some xml comments and code feedback

lanlanlee2008 · lanlanlee2008 · commit 4de8975d93ff · 2016-07-12T18:48:31.000-07:00
diff --git a/src/CustomOutputCacheProvider/CustomOutputCacheProvider.cs b/src/CustomOutputCacheProvider/CustomOutputCacheProvider.cs
@@ -5,20 +5,25 @@
 
 namespace Microsoft.AspNet.OutputCache.CustomOutputCacheProvider {
 
-    public class CustomOutputCacheItem {
+    internal class CustomOutputCacheItem {
         public object Obj;
         public DateTime UtcExpiry;
-
         public CustomOutputCacheItem(object entry, DateTime utcExpiryIn) {
             Obj = entry;
             UtcExpiry = utcExpiryIn;
         }
     }
 
+    /// <summary>
+    /// This is just a proof of concept Async OutputCache Provider. It is used for testing purpose.
+    /// </summary>
     public class CustomOutputCacheProvider : OutputCacheProviderAsync {
 
         private readonly Dictionary<string, CustomOutputCacheItem> _dict;
 
+        /// <summary>
+        /// Async OutputCache Provider
+        /// </summary>
         public CustomOutputCacheProvider() {
             _dict = new Dictionary<string, CustomOutputCacheItem>();
         }
@@ -27,6 +32,11 @@ private static async Task FooAsync() {
             await Task.Delay(1);
         }
 
+        /// <summary>
+        /// Override method for the Async OutputCache Provider
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
         public override async Task<object> GetAsync(string key) {
             await FooAsync();
             if (!_dict.ContainsKey(key)) {
@@ -40,6 +50,13 @@ public override async Task<object> GetAsync(string key) {
         }
 
 
+        /// <summary>
+        /// Override method for the Async OutputCache Provider
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="entry"></param>
+        /// <param name="utcExpiry"></param>
+        /// <returns></returns>
         public override async Task<object> AddAsync(string key, object entry, DateTime utcExpiry) {
             await FooAsync();
             if (_dict.ContainsKey(key) && _dict[key].UtcExpiry > DateTime.Now.ToUniversalTime()) {
@@ -54,6 +71,13 @@ public override async Task<object> AddAsync(string key, object entry, DateTime u
             return entry;
         }
 
+        /// <summary>
+        /// Override method for the Async OutputCache Provider
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="entry"></param>
+        /// <param name="utcExpiry"></param>
+        /// <returns></returns>
         public override async Task SetAsync(string key, object entry, DateTime utcExpiry) {
             await FooAsync();
             if (_dict.ContainsKey(key)) {
@@ -64,11 +88,21 @@ public override async Task SetAsync(string key, object entry, DateTime utcExpiry
             }
         }
 
+        /// <summary>
+        /// Override method for the Async OutputCache Provider
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
         public override async Task RemoveAsync(string key) {
             await FooAsync();
             _dict.Remove(key);
         }
 
+        /// <summary>
+        /// Override method for the Async OutputCache Provider
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
         public override object Get(string key) {
             if (!_dict.ContainsKey(key)) {
                 return null;
@@ -80,6 +114,13 @@ public override object Get(string key) {
             return null;
         }
 
+        /// <summary>
+        /// Override method for the Async OutputCache Provider
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="entry"></param>
+        /// <param name="utcExpiry"></param>
+        /// <returns></returns>
         public override object Add(string key, object entry, DateTime utcExpiry) {
             if (_dict.ContainsKey(key) && _dict[key].UtcExpiry > DateTime.Now.ToUniversalTime()) {
                 return _dict[key].Obj;
@@ -93,6 +134,12 @@ public override object Add(string key, object entry, DateTime utcExpiry) {
             return entry;
         }
 
+        /// <summary>
+        /// Override method for the Async OutputCache Provider
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="entry"></param>
+        /// <param name="utcExpiry"></param>
         public override void Set(string key, object entry, DateTime utcExpiry) {
             if (_dict.ContainsKey(key)) {
                 _dict[key] = new CustomOutputCacheItem(entry, utcExpiry);
@@ -102,6 +149,10 @@ public override void Set(string key, object entry, DateTime utcExpiry) {
             }
         }
 
+        /// <summary>
+        /// Override method for the Async OutputCache Provider
+        /// </summary>
+        /// <param name="key"></param>
         public override void Remove(string key) {
             _dict.Remove(key);
         }
diff --git a/src/OutputCacheModuleAsync/InMemoryOutputCacheProvider.cs b/src/OutputCacheModuleAsync/InMemoryOutputCacheProvider.cs
@@ -8,11 +8,11 @@ internal class InMemoryOutputCacheProvider : OutputCacheProviderAsync {
         private readonly MemoryCache _cache = new MemoryCache("Microsoft.AspNet.OutputCache Default In-Memory Provider");
 
         public override Task<object> GetAsync(string key) {
-            return Task.Run(() => Get(key));
+            return Task.FromResult(Get(key)); //.Run(() => Get(key));
         }
 
         public override Task<object> AddAsync(string key, object entry, DateTime utcExpiry) {
-            return Task.Run(() => Add(key, entry, utcExpiry));
+            return Task.FromResult(Add(key,entry,utcExpiry));//.Run(() => Add(key, entry, utcExpiry));
         }
 
         public override Task SetAsync(string key, object entry, DateTime utcExpiry) {
diff --git a/src/OutputCacheModuleAsync/OutputCacheHelper.cs b/src/OutputCacheModuleAsync/OutputCacheHelper.cs
@@ -1,4 +1,6 @@
-﻿namespace Microsoft.AspNet.OutputCache {
+﻿using System.IO;
+
+namespace Microsoft.AspNet.OutputCache {
     using System.Collections.Generic;
     using System.Linq;
     using System;
@@ -388,7 +390,7 @@ public static void UpdateCachedHeaders(HttpResponse response) {
             }
         }
 
-        public static async Task<string> CreateOutputCachedItemKeyAsync(
+        public static string CreateOutputCachedItemKey(
             string path,
             string verb,
             HttpContext context,
@@ -494,13 +496,18 @@ public static async Task<string> CreateOutputCachedItemKeyAsync(
                     return null;
                 }
                 if (contentLength > 0) {
-                    await request.InputStream.ReadAsync(null, 0, System.Convert.ToInt32(request.InputStream.Length));
-                    return null;
+                    using (var ms = new MemoryStream()) {
+                        request.InputStream.CopyTo(ms);
+                        byte[] buf = ms.ToArray();
+                        // Use SHA256 to generate a collision-free hash of the input data
+                        value = System.Convert.ToBase64String((CryptoUtil.ComputeSha256Hash(buf)));
+                        sb.Append(value);
+                    }
                 }
             }
             /*
-                 * VaryByContentEncoding
-                 */
+            * VaryByContentEncoding
+            */
             sb.Append("E");
             string[] contentEncodings = cachedVary.ContentEncodings;
             if (contentEncodings == null) {
@@ -522,9 +529,8 @@ public static async Task<string> CreateOutputCachedItemKeyAsync(
          * and form posted data.
          */
 
-        public static async Task<string> CreateOutputCachedItemKeyAsync(HttpContext context, CachedVary cachedVary) {
-            return
-                await CreateOutputCachedItemKeyAsync(context.Request.Path, context.Request.HttpMethod, context, cachedVary);
+        public static string CreateOutputCachedItemKeyAsync(HttpContext context, CachedVary cachedVary) {
+            return CreateOutputCachedItemKey(context.Request.Path, context.Request.HttpMethod, context, cachedVary);
         }
 
         /*
@@ -553,7 +559,7 @@ public static int GetAcceptableEncoding(string[] contentEncodings, int startInde
                     }
                     acceptEncodingWithoutWeight = acceptEncoding.Substring(0, tokenEnd);
                     if (Math.Abs(ParseWeight(acceptEncoding, tokenEnd)) < 0) {
-                        // WOS 1985352 & WOS 1985353: weight is 0, use "identity" only if it is acceptable
+                        //weight is 0, use "identity" only if it is acceptable
                         bool identityIsAcceptable = acceptEncodingWithoutWeight != Identity &&
                                                     acceptEncodingWithoutWeight != Asterisk;
                         return (identityIsAcceptable) ? -1 : -2;
diff --git a/src/OutputCacheModuleAsync/OutputCacheModuleAsync.cs b/src/OutputCacheModuleAsync/OutputCacheModuleAsync.cs
@@ -11,6 +11,9 @@
     using System.Diagnostics;
     using System.Configuration;
 
+    /// <summary>
+    /// OutputCache Async Module, this Module is able to use Async type of OutputCache Providers 
+    /// </summary>
     public class OutputCacheModuleAsync : IHttpModule {
         private const string Asterisk = "*";
         private static readonly char[] s_fieldSeparators = {',', ' '};
@@ -27,6 +30,9 @@ void IHttpModule.Init(HttpApplication app) {
             app.AddOnUpdateRequestCacheAsync(BeginOnUpdateRequestCache, EndOnUpdateRequestCache);
         }
 
+        /// <summary>
+        /// Implement the IHTTPModule interface
+        /// </summary>
         public void Dispose() {}
 
         private IAsyncResult BeginOnResolveRequestCache(object source, EventArgs e, AsyncCallback cb, object extraData) {
diff --git a/src/OutputCacheModuleAsync/Util.cs b/src/OutputCacheModuleAsync/Util.cs
@@ -22,6 +22,35 @@ public int Compare(object a, object b) {
         }
     }
 
+    internal class CryptoUtil {
+        /// <summary>
+        /// Computes the SHA256 hash of a given input.
+        /// </summary>
+        /// <param Name="input">The input over which to compute the hash.</param>
+        /// <param name="input"></param>
+        /// <returns>The binary hash (32 bytes) of the input.</returns>
+        public static byte[] ComputeSha256Hash(byte[] input) {
+            return ComputeSha256Hash(input, 0, input.Length);
+        }
+
+        /// <summary>
+        /// Computes the SHA256 hash of a given segment in a buffer.
+        /// </summary>
+        /// <param Name="buffer">The buffer over which to compute the hash.</param>
+        /// <param Name="offset">The offset at which to begin computing the hash.</param>
+        /// <param Name="count">The number of bytes in the buffer to include in the hash.</param>
+        /// <param name="buffer"></param>
+        /// <param name="offset"></param>
+        /// <param name="count"></param>
+        /// <returns>The binary hash (32 bytes) of the buffer segment.</returns>
+        public static byte[] ComputeSha256Hash(byte[] buffer, int offset, int count) {
+
+            using (SHA256 sha256 = new SHA256Cng()) {
+                return sha256.ComputeHash(buffer, offset, count);
+            }
+        }
+    }
+
     internal class HttpDate {
         private static readonly int[] s_tensDigit = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90};
 
diff --git a/src/packages/CustomOutputCacheProvider.nupkg/Microsoft.AspNet.OutputCache.CustomOutputCacheProvider.nuspec b/src/packages/CustomOutputCacheProvider.nupkg/Microsoft.AspNet.OutputCache.CustomOutputCacheProvider.nuspec
@@ -8,7 +8,6 @@
     <copyright>&#169; Microsoft Corporation. All rights reserved.</copyright>
     <dependencies>
       <dependency id="Microsoft.AspNet.OutputCache.OutputCacheModuleAsync" version="$OutputCacheModuleAsyncNuGetPackageVersion$" />
-      <dependency id="EntityFramework" version="$EntityFrameworkNuGetPackageVersion$" />
     </dependencies>    
     <title>Microsoft ASP.NET Custom OutputCache Providers</title>
     <description>Async version Custom OutputCache provider</description>
diff --git a/src/packages/CustomOutputCacheProvider.nupkg/content/Net462/web.config.install.xdt b/src/packages/CustomOutputCacheProvider.nupkg/content/Net462/web.config.install.xdt
@@ -1,15 +1,17 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
   <system.web>
-    <outputCache xdt:Transform="Remove">
-    </outputCache>
+    <caching>
+	 <outputCache xdt:Transform="Remove">
+	 </outputCache>
+    </caching>
   </system.web> 
  <system.web>
-     <caching>
-      <outputCache defaultProvider="CustomOutputCacheProvider" xdt:Transform="Insert"> 
+     <caching xdt:Transform="InsertIfMissing">
+      <outputCache defaultProvider="CustomOutputCacheProvider" xdt:Transform="InsertIfMissing"> 
         <providers>
           <add name="CustomOutputCacheProvider"
-              type="Microsoft.AspNet.OutputCache.CustomOutputCacheProvider, CustomOutputCacheProvider"
+              type="Microsoft.AspNet.OutputCache.CustomOutputCacheProvider.CustomOutputCacheProvider, Microsoft.AspNet.OutputCache.CustomOutputCacheProvider"
               xdt:Transform="InsertIfMissing" />
         </providers>
       </outputCache>
diff --git a/src/packages/CustomOutputCacheProvider.nupkg/content/Net462/web.config.uninstall.xdt b/src/packages/CustomOutputCacheProvider.nupkg/content/Net462/web.config.uninstall.xdt
@@ -5,7 +5,7 @@
       <outputCache defaultProvider="CustomOutputCacheProvider" xdt:Transform="Remove"> 
         <providers>
           <add name="CustomOutputCacheProvider"
-              type="Microsoft.AspNet.OutputCache.CustomOutputCacheProvider, CustomOutputCacheProvider"
+              type="Microsoft.AspNet.OutputCache.CustomOutputCacheProvider.CustomOutputCacheProvider, Microsoft.AspNet.OutputCache.CustomOutputCacheProvider"
               xdt:Transform="Remove" xdt:Locator="Match(type)"  />
         </providers>
       </outputCache>
diff --git a/tools/MicrosoftAspNetOutputCache.Extensions.settings.targets b/tools/MicrosoftAspNetOutputCache.Extensions.settings.targets
@@ -54,7 +54,7 @@
             <AuthCodeCert>10006</AuthCodeCert>
             <StrongNameCert>72</StrongNameCert>
         </CodeSign>
-<CodeSign Include="$(OutputPath)Microsoft.AspNet.OutputCache.CustomOutputCacheProvider.dll">
+        <CodeSign Include="$(OutputPath)Microsoft.AspNet.OutputCache.CustomOutputCacheProvider.dll">
             <AuthCodeCert>10006</AuthCodeCert>
             <StrongNameCert>72</StrongNameCert>
         </CodeSign>
diff --git a/tools/MicrosoftAspNetOutputCache.settings.targets b/tools/MicrosoftAspNetOutputCache.settings.targets
@@ -16,8 +16,7 @@
   </PropertyGroup>
 
   <PropertyGroup Label="NuGet package dependencies">
-    <OutputCacheAsyncModuleNuGetPackageVersion>1.0.0</OutputCacheAsyncModuleNuGetPackageVersion>
-    <EntityFrameworkNuGetPackageVersion>6.1.3</EntityFrameworkNuGetPackageVersion>
+    <OutputCacheModuleAsyncNuGetPackageVersion>1.0.0</OutputCacheModuleAsyncNuGetPackageVersion>
   </PropertyGroup>
 
   <!-- Default properties -->
diff --git a/tools/MicrosoftAspNetOutputCache.targets b/tools/MicrosoftAspNetOutputCache.targets
@@ -22,8 +22,7 @@
             <NuSpecProperties>
                 NuGetPackageVersion=$(NuGetPackageVersion);
                 NuGetPackageId=$(NuGetPackageId);
-		OutputCacheAsyncModuleNuGetPackageVersion=$(OutputCacheAsyncModuleNuGetPackageVersion);
-		EntityFrameworkNuGetPackageVersion=$(EntityFrameworkNuGetPackageVersion)
+            		OutputCacheModuleAsyncNuGetPackageVersion=$(OutputCacheModuleAsyncNuGetPackageVersion);
             </NuSpecProperties>
         </PropertyGroup>
     </Target>

Original file line number	Diff line number	Diff line change
`@@ -8,11 +8,11 @@ internal class InMemoryOutputCacheProvider : OutputCacheProviderAsync {`
`8`	`8`	`private readonly MemoryCache _cache = new MemoryCache("Microsoft.AspNet.OutputCache Default In-Memory Provider");`
`9`	`9`
`10`	`10`	`public override Task<object> GetAsync(string key) {`
`11`		`- return Task.Run(() => Get(key));`
	`11`	`+ return Task.FromResult(Get(key)); //.Run(() => Get(key));`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`public override Task<object> AddAsync(string key, object entry, DateTime utcExpiry) {`
`15`		`- return Task.Run(() => Add(key, entry, utcExpiry));`
	`15`	`+ return Task.FromResult(Add(key,entry,utcExpiry));//.Run(() => Add(key, entry, utcExpiry));`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`public override Task SetAsync(string key, object entry, DateTime utcExpiry) {`