[CacheControl] Can use custom connection string; tests; can use post data

CacheControl-test/Controllers/MyCacheOutputAttribute.cs

-using CacheControl.DBO;
+using System.Configuration;
 using iiie.CacheControl.Business.Attributes;
 using iiie.CacheControl.Business.OutputCache;
 
 {
     public class MyCacheOutputAttribute : TimeCacheControlAttribute
     {
-        public MyCacheOutputAttribute(int seconds) : base(seconds)
+        public MyCacheOutputAttribute(int seconds, bool excludeGet = false, bool excludePost = false) : base(seconds)
         {
             CacheType = OutputCacheType.DataBase;
+            ExcludePostFromCacheKey = excludePost;
+            ExcludeQueryStringFromCacheKey = excludeGet;
+            OutputCacheData = ConfigurationManager.ConnectionStrings["ConnectionString42"].ConnectionString;
         }
     }
 }

CacheControl-test/Controllers/ValuesController.cs

     public class ValuesController : ApiController
     {
         // GET api/values
+        // Ignore all parameters
+        [MyCacheOutput(30, true, true)]
         public IEnumerable<string> Get()
         {
             return new string[] { "value1", "value2" };
         }
 
         // GET api/values/5
-        [MyCacheOutput(60)]
+        // Ignore post
+        [MyCacheOutput(30, false, true)]
         public string Get(int id)
         {
-            return "value";
+            return "get value";
         }
 
         // POST api/values
-        public void Post([FromBody]string value)
+        // Ignore get
+        [MyCacheOutput(30, true)]
+        public string Post([FromBody]IEnumerable<int> value)
         {
+            return "post value";
         }
 
         // PUT api/values/5
-        public void Put(int id, [FromBody]string value)
-        {
-        }
-
-        // DELETE api/values/5
-        public void Delete(int id)
+        // cache all
+        [MyCacheOutput(30)]
+        public string Put([FromUri]int id, [FromBody]string value)
         {
+            return "put";
         }
     }
 }

CacheControl-test/Web.config

     </handlers>
   </system.webServer>
   <connectionStrings>
-    <add name="CacheControlEntities" connectionString="metadata=res://*/DataAccess.CacheEntities.csdl|res://*/DataAccess.CacheEntities.ssdl|res://*/DataAccess.CacheEntities.msl;provider=System.Data.SqlClient;provider connection string=&quot;data source=.;initial catalog=CacheControl;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework&quot;" providerName="System.Data.EntityClient" />
+    <add name="ConnectionString42" connectionString="metadata=res://*/DataAccess.CacheEntities.csdl|res://*/DataAccess.CacheEntities.ssdl|res://*/DataAccess.CacheEntities.msl;provider=System.Data.SqlClient;provider connection string=&quot;data source=.;initial catalog=CacheControl;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework&quot;" providerName="System.Data.EntityClient" />
   </connectionStrings>
   <entityFramework>
     <defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">

CacheControl/Business/Attributes/CacheControlAttribute.cs

         /// </summary>
         protected bool ExcludeQueryStringFromCacheKey { get; set; }
 
+        /// <summary>
+        /// Indicates if the post data must be used to control cache
+        /// </summary>
+        protected bool ExcludePostFromCacheKey { get; set; }
+
+        /// <summary>
+        /// Optionnal data used by ouput cache backend
+        /// </summary>
+        public object OutputCacheData { get; set; }
+
         /// <summary>
         /// Define the cache type used to store cache
         /// </summary>
 
         private IOutputCache _webCache;
 
-        protected void EnsureCache(HttpConfiguration config, HttpRequestMessage req)
-        {
-            _webCache = config.CacheOutputConfiguration(CacheType).GetCacheOutputProvider(req);
-        }
-
         protected abstract bool IsValid(CacheDbo data);
 
         protected virtual CacheDbo CreateCacheUser()
 
             var config = actionContext.Request.GetConfiguration();
 
-            EnsureCache(config, actionContext.Request);
+            _webCache = config.CacheOutputConfiguration(CacheType).GetCacheOutputProvider(actionContext.Request, OutputCacheData);
 
             var cacheKeyGenerator = config.CacheOutputConfiguration(CacheType).GetCacheKeyGenerator(actionContext.Request, CacheKeyGenerator);
 
             _responseMediaType = GetExpectedMediaType(config, actionContext);
 
-            var cachekey = cacheKeyGenerator.MakeCacheKey(actionContext, _responseMediaType, CacheType, ExcludeQueryStringFromCacheKey);
+            var cachekey = cacheKeyGenerator.MakeCacheKey(actionContext, _responseMediaType, CacheType,
+                ExcludeQueryStringFromCacheKey, ExcludePostFromCacheKey);
 
             var data = _webCache.Get(cachekey);
             if (data == null)
             var config = actionExecutedContext.Request.GetConfiguration().CacheOutputConfiguration(CacheType);
             var cacheKeyGenerator = config.GetCacheKeyGenerator(actionExecutedContext.Request, CacheKeyGenerator);
 
-            var cachekey = cacheKeyGenerator.MakeCacheKey(actionExecutedContext.ActionContext, _responseMediaType, CacheType, ExcludeQueryStringFromCacheKey);
+            var cachekey = cacheKeyGenerator.MakeCacheKey(actionExecutedContext.ActionContext, _responseMediaType,
+                CacheType, ExcludeQueryStringFromCacheKey, ExcludePostFromCacheKey);
 
             if (!string.IsNullOrWhiteSpace(cachekey) && !(_webCache.Contains(cachekey)))
             {

CacheControl/Business/Attributes/TimeCacheControlAttribute.cs

 using System;
 using iiie.CacheControl.Attributes;
-using iiie.CacheControl.Business.OutputCache;
 using iiie.CacheControl.DBO;
 
 namespace iiie.CacheControl.Business.Attributes

CacheControl/Business/CacheKey/DefaultCacheKeyGenerator.cs

-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Web;
 using System.Web.Http.Controllers;
-using iiie.CacheControl.Business.HttpExtensions;
 using iiie.CacheControl.Business.OutputCache;
+using Newtonsoft.Json;
 
 namespace iiie.CacheControl.Business.CacheKey
 {
     public class DefaultCacheKeyGenerator : ICacheKeyGenerator
     {
-        public virtual string MakeCacheKey(HttpActionContext context, MediaTypeHeaderValue mediaType, OutputCacheType cacheType, bool excludeQueryString = false)
+        public virtual string MakeCacheKey(HttpActionContext context, MediaTypeHeaderValue mediaType,
+            OutputCacheType cacheType, bool excludeQueryString = false, bool excludePost = false)
         {
-            var controller = context.ControllerContext.ControllerDescriptor.ControllerName;
-            var action = context.ActionDescriptor.ActionName;
-            var key = context.Request.GetConfiguration().CacheOutputConfiguration(cacheType).MakeBaseCachekey(controller, action);
-            var actionParameters = context.ActionArguments.Where(x => x.Value != null).Select(x => x.Key + "=" + GetValue(x.Value));
-
-            string parameters;
+            string parameters = context.Request.Method.Method + "-" + context.Request.RequestUri.AbsolutePath;
 
             if (!excludeQueryString)
             {
-                var queryStringParameters =
-                    context.Request.GetQueryNameValuePairs()
-                           .Where(x => x.Key.ToLower() != "callback" && x.Key.ToLower() != "_")
-                           .Select(x => x.Key + "=" + x.Value);
-                var parametersCollections = actionParameters.Union(queryStringParameters);
-                parameters = "-" + string.Join("&", parametersCollections);
-
-                var callbackValue = GetJsonpCallback(context.Request);
-                if (!string.IsNullOrWhiteSpace(callbackValue))
-                {
-                    var callback = "callback=" + callbackValue;
-                    if (parameters.Contains("&" + callback)) parameters = parameters.Replace("&" + callback, string.Empty);
-                    if (parameters.Contains(callback + "&")) parameters = parameters.Replace(callback + "&", string.Empty);
-                    if (parameters.Contains("-" + callback)) parameters = parameters.Replace("-" + callback, string.Empty);
-                    if (parameters.EndsWith("&")) parameters = parameters.TrimEnd('&');
-                }
+                var pairs = context.Request.GetQueryNameValuePairs().OrderBy(x => x.Key);
+                parameters += "?" + string.Join("&", pairs.Select(x => HttpUtility.UrlEncode(x.Key)
+                    + "=" + HttpUtility.UrlEncode(x.Value)));
             }
-            else
+            if (!excludePost)
             {
-                parameters = "-" + string.Join("&", actionParameters);
+                parameters += "?" + string.Join("&", context.ActionArguments.Select(x => HttpUtility.UrlEncode(x.Key)
+                    + "=" + HttpUtility.UrlEncode(JsonConvert.SerializeObject(x.Value))));
             }
 
-            if (parameters == "-") parameters = string.Empty;
-
-            var cachekey = string.Format("{0}{1}:{2}", key, parameters, mediaType.MediaType);
+            var cachekey = string.Format("{0}:{1}", parameters, mediaType.MediaType);
             return cachekey;
         }
-
-        private string GetJsonpCallback(HttpRequestMessage request)
-        {
-            var callback = string.Empty;
-            if (request.Method == HttpMethod.Get)
-            {
-                var query = request.GetQueryNameValuePairs();
-
-                if (query != null)
-                {
-                    var queryVal = query.FirstOrDefault(x => x.Key.ToLower() == "callback");
-                    if (!queryVal.Equals(default(KeyValuePair<string, string>))) callback = queryVal.Value;
-                }
-            }
-            return callback;
-        }
-
-        private string GetValue(object val)
-        {
-            if (val is IEnumerable && !(val is string))
-            {
-                var concatValue = string.Empty;
-                var paramArray = val as IEnumerable;
-                return paramArray.Cast<object>().Aggregate(concatValue, (current, paramValue) => current + (paramValue + ";"));
-            }
-            return val.ToString();
-        }
     }
 }

CacheControl/Business/CacheKey/ICacheKeyGenerator.cs

 {
     public interface ICacheKeyGenerator
     {
-        string MakeCacheKey(HttpActionContext context, MediaTypeHeaderValue mediaType, OutputCacheType cacheType, bool excludeQueryString = false);
+        string MakeCacheKey(HttpActionContext context, MediaTypeHeaderValue mediaType,
+            OutputCacheType cacheType, bool excludeQueryString = false, bool excludePost = false);
     }
 }

CacheControl/Business/HttpExtensions/CacheOutputConfiguration.cs

 using System;
 using System.Linq;
-using System.Linq.Expressions;
 using System.Net.Http;
 using System.Reflection;
 using System.Web.Http;
-using CacheControl.DBO;
 using iiie.CacheControl.Business.CacheKey;
 using iiie.CacheControl.Business.OutputCache;
 
             _cacheType = type;
         }
 
-        public void RegisterCacheOutputProvider(Func<IOutputCache> provider)
-        {
-            _configuration.Properties.GetOrAdd(typeof(IOutputCache), x => provider);
-        }
-
-        public void RegisterCacheKeyGeneratorProvider<T>(Func<T> provider)
-            where T : ICacheKeyGenerator
-        {
-            _configuration.Properties.GetOrAdd(typeof(T), x => provider);
-        }
-
-        public void RegisterDefaultCacheKeyGeneratorProvider(Func<ICacheKeyGenerator> provider)
-        {
-            RegisterCacheKeyGeneratorProvider(provider);
-        }
-
-        public string MakeBaseCachekey(string controller, string action)
-        {
-            return string.Format("{0}-{1}", controller.ToLower(), action.ToLower());
-        }
-
-        public string MakeBaseCachekey<T, U>(Expression<Func<T, U>> expression)
-        {
-            var method = expression.Body as MethodCallExpression;
-            if (method == null) throw new ArgumentException("Expression is wrong");
-
-            var methodName = method.Method.Name;
-            var nameAttribs = method.Method.GetCustomAttributes(typeof(ActionNameAttribute), false);
-            if (nameAttribs.Any())
-            {
-                var actionNameAttrib = (ActionNameAttribute)nameAttribs.FirstOrDefault();
-                if (actionNameAttrib != null)
-                {
-                    methodName = actionNameAttrib.Name;
-                }
-            }
-
-            return string.Format("{0}-{1}", typeof(T).Name.Replace("Controller", string.Empty).ToLower(), methodName.ToLower());
-        }
-
         private static ICacheKeyGenerator TryActivateCacheKeyGenerator(Type generatorType)
         {
             var hasEmptyOrDefaultConstructor =
                 ?? new DefaultCacheKeyGenerator();
         }
 
-        public IOutputCache GetCacheOutputProvider(HttpRequestMessage request)
+        public IOutputCache GetCacheOutputProvider(HttpRequestMessage request, object outputCacheData)
         {
             object cache;
             _configuration.Properties.TryGetValue(typeof(IOutputCache), out cache);
             if (cacheOutputProvider == null)
             {
                 if (_cacheType == OutputCacheType.DataBase)
+                {
                     cacheOutputProvider = new DbOutputCache();
+                    ((DbOutputCache) cacheOutputProvider).ConnectionString = outputCacheData as string;
+                }
                 else
                     cacheOutputProvider = new MemoryOutputCache();
             }

CacheControl/Business/OutputCache/DbOutputCache.cs

-using System;
-using System.Linq;
-using CacheControl.DataAccess;
+using System.Linq;
+using iiie.CacheControl.DataAccess;
 using iiie.CacheControl.DBO;
 
 namespace iiie.CacheControl.Business.OutputCache
 {
     public class DbOutputCache : IOutputCache
     {
+        public string ConnectionString { get; set; }
+
+        private CacheControlEntities GetDb()
+        {
+            if (ConnectionString == null)
+                return new CacheControlEntities();
+            return new CacheControlEntities(ConnectionString);
+        }
 
         public override CacheDbo Get(string key)
         {
-            using (var db = new CacheControlEntities())
+            using (var db = GetDb())
             {
                 var item = db.T_Cache.FirstOrDefault(x => x.cachekey == key);
                 if (item == null)
 
         public override void Remove(string key)
         {
-            using (var db = new CacheControlEntities())
+            using (var db = GetDb())
             {
                 var item = db.T_Cache.FirstOrDefault(x => x.cachekey == key);
                 if (item != null)
 
         public override bool Contains(string key)
         {
-            using (var db = new CacheControlEntities())
+            using (var db = GetDb())
             {
                 return db.T_Cache.Any(x => x.cachekey == key);
             }
 
         public override void Add(string key, CacheDbo o)
         {
-            using (var db = new CacheControlEntities())
+            using (var db = GetDb())
             {
                 db.T_Cache.Add(new T_Cache
                 {

CacheControl/CacheControl.csproj

     <ProjectGuid>{BA63D177-BE9E-41E0-89F5-3D134A26A604}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>CacheControl</RootNamespace>
+    <RootNamespace>iiie.CacheControl</RootNamespace>
     <AssemblyName>CacheControl</AssemblyName>
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>

CacheControl/DataAccess/CacheEntities.Context.cs

 // </auto-generated>
 //------------------------------------------------------------------------------
 
-namespace CacheControl.DataAccess
+namespace iiie.CacheControl.DataAccess
 {
     using System;
     using System.Data.Entity;
         {
         }
     
+    	public CacheControlEntities(String connectionString)
+            : base(connectionString)
+        {
+    	}
+    
         protected override void OnModelCreating(DbModelBuilder modelBuilder)
         {
             throw new UnintentionalCodeFirstException();

CacheControl/DataAccess/CacheEntities.Context.tt

 #>
     }
 
+	public <#=code.Escape(container)#>(String connectionString)
+        : base(connectionString)
+    {
+	}
+
     protected override void OnModelCreating(DbModelBuilder modelBuilder)
     {
         throw new UnintentionalCodeFirstException();

CacheControl/DataAccess/T_Cache.cs

 // </auto-generated>
 //------------------------------------------------------------------------------
 
-namespace CacheControl.DataAccess
+namespace iiie.CacheControl.DataAccess
 {
     using System;
     using System.Collections.Generic;