[CacheControl] Imported v1.0

CacheControl/Business/Attributes/CacheControlAttribute.cs

@@ -0,0 +1,245 @@
+using System;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Formatting;
+using System.Net.Http.Headers;
+using System.Runtime.ExceptionServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http;
+using System.Web.Http.Controllers;
+using System.Web.Http.Filters;
+using iiie.CacheControl.Business.HttpExtensions;
+using iiie.CacheControl.Business.OutputCache;
+using iiie.CacheControl.DBO;
+
+namespace iiie.CacheControl.Attributes
+{
+    [AttributeUsage(AttributeTargets.Method)]
+    public abstract class CacheControlAttribute : FilterAttribute, IActionFilter
+    {
+        protected static MediaTypeHeaderValue DefaultMediaType = new MediaTypeHeaderValue("application/json");
+
+        /// <summary>
+        /// Indicates if the client can reuse cached data without asking origin server
+        /// </summary>
+        protected bool MustRevalidate { get; set; }
+
+        /// <summary>
+        /// Indicates if the query string must be used to control cache
+        /// </summary>
+        protected bool ExcludeQueryStringFromCacheKey { get; set; }
+
+        /// <summary>
+        /// Define the cache type used to store cache
+        /// </summary>
+        protected OutputCacheType CacheType { get; set; }
+
+        protected Type CacheKeyGenerator { get; set; }
+
+        private MediaTypeHeaderValue _responseMediaType;
+
+        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()
+        {
+            return new CacheDbo();
+        }
+
+        protected virtual MediaTypeHeaderValue GetExpectedMediaType(HttpConfiguration config, HttpActionContext actionContext)
+        {
+            MediaTypeHeaderValue responseMediaType = null;
+
+            var negotiator = config.Services.GetService(typeof(IContentNegotiator)) as IContentNegotiator;
+            var returnType = actionContext.ActionDescriptor.ReturnType;
+
+            if (negotiator != null && returnType != typeof(HttpResponseMessage))
+            {
+                var negotiatedResult = negotiator.Negotiate(returnType, actionContext.Request, config.Formatters);
+                responseMediaType = negotiatedResult.MediaType;
+                responseMediaType.CharSet = Encoding.UTF8.HeaderName;
+            }
+            else
+            {
+                if (actionContext.Request.Headers.Accept != null)
+                {
+                    responseMediaType = actionContext.Request.Headers.Accept.FirstOrDefault();
+                    if (responseMediaType == null ||
+                        !config.Formatters.Any(x => x.SupportedMediaTypes.Contains(responseMediaType)))
+                    {
+                        DefaultMediaType.CharSet = Encoding.UTF8.HeaderName;
+                        return DefaultMediaType;
+                    }
+                }
+            }
+
+            return responseMediaType;
+        }
+
+        private void OnActionExecuting(HttpActionContext actionContext)
+        {
+            if (actionContext == null) throw new ArgumentNullException("actionContext");
+
+            var config = actionContext.Request.GetConfiguration();
+
+            EnsureCache(config, actionContext.Request);
+
+            var cacheKeyGenerator = config.CacheOutputConfiguration(CacheType).GetCacheKeyGenerator(actionContext.Request, CacheKeyGenerator);
+
+            _responseMediaType = GetExpectedMediaType(config, actionContext);
+
+            var cachekey = cacheKeyGenerator.MakeCacheKey(actionContext, _responseMediaType, CacheType, ExcludeQueryStringFromCacheKey);
+
+            var data = _webCache.Get(cachekey) as CacheDbo;
+            if (data == null) return;
+
+            if (!IsValid(data))
+            {
+                _webCache.Remove(cachekey);
+                return;
+            }
+
+            if (actionContext.Request.Headers.IfNoneMatch != null)
+            {
+                if (data.ETag != null)
+                {
+                    if (actionContext.Request.Headers.IfNoneMatch.Any(x => x.Tag == data.ETag))
+                    {
+                        var quickResponse = actionContext.Request.CreateResponse(HttpStatusCode.NotModified);
+                        ApplyCacheHeaders(quickResponse);
+                        actionContext.Response = quickResponse;
+                        return;
+                    }
+                }
+            }
+
+            if (data.Content == null) return;
+
+            actionContext.Response = actionContext.Request.CreateResponse();
+            actionContext.Response.Content = new ByteArrayContent(data.Content);
+
+            actionContext.Response.Content.Headers.ContentType = new MediaTypeHeaderValue(data.ContentType);
+            if (data.ETag != null) SetEtag(actionContext.Response, data.ETag);
+
+            ApplyCacheHeaders(actionContext.Response);
+        }
+
+        private async Task OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
+        {
+            if (actionExecutedContext.ActionContext.Response == null || !actionExecutedContext.ActionContext.Response.IsSuccessStatusCode) return;
+
+            var config = actionExecutedContext.Request.GetConfiguration().CacheOutputConfiguration(CacheType);
+            var cacheKeyGenerator = config.GetCacheKeyGenerator(actionExecutedContext.Request, CacheKeyGenerator);
+
+            var cachekey = cacheKeyGenerator.MakeCacheKey(actionExecutedContext.ActionContext, _responseMediaType, CacheType, ExcludeQueryStringFromCacheKey);
+
+            if (!string.IsNullOrWhiteSpace(cachekey) && !(_webCache.Contains(cachekey)))
+            {
+                SetEtag(actionExecutedContext.Response, Guid.NewGuid().ToString());
+
+                if (actionExecutedContext.Response.Content != null)
+                {
+                    var data = CreateCacheUser();
+                    data.Content = await actionExecutedContext.Response.Content.ReadAsByteArrayAsync();
+                    data.ContentType = actionExecutedContext.Response.Content.Headers.ContentType.MediaType;
+                    data.ETag = actionExecutedContext.Response.Headers.ETag.Tag;
+                    data.Date = DateTime.Now;
+
+                    _webCache.Add(cachekey, data);
+                }
+            }
+
+            ApplyCacheHeaders(actionExecutedContext.ActionContext.Response);
+        }
+
+        private void ApplyCacheHeaders(HttpResponseMessage response)
+        {
+            if (MustRevalidate)
+            {
+                response.Headers.CacheControl = new CacheControlHeaderValue
+                {
+                    MustRevalidate = MustRevalidate
+                };
+            }
+        }
+
+        private static void SetEtag(HttpResponseMessage message, string etag)
+        {
+            if (etag != null)
+            {
+                message.Headers.ETag = new EntityTagHeaderValue(@"""" + etag.Replace("\"", string.Empty) + @"""");
+            }
+        }
+
+        Task<HttpResponseMessage> IActionFilter.ExecuteActionFilterAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func<Task<HttpResponseMessage>> continuation)
+        {
+            if (actionContext == null)
+            {
+                throw new ArgumentNullException("actionContext");
+            }
+
+            if (continuation == null)
+            {
+                throw new ArgumentNullException("continuation");
+            }
+
+            OnActionExecuting(actionContext);
+
+            if (actionContext.Response != null)
+            {
+                return Task.FromResult(actionContext.Response);
+            }
+
+            return CallOnActionExecutedAsync(actionContext, cancellationToken, continuation);
+        }
+
+        private async Task<HttpResponseMessage> CallOnActionExecutedAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func<Task<HttpResponseMessage>> continuation)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            HttpResponseMessage response = null;
+            Exception exception = null;
+            try
+            {
+                response = await continuation();
+            }
+            catch (Exception e)
+            {
+                exception = e;
+            }
+
+            try
+            {
+                var executedContext = new HttpActionExecutedContext(actionContext, exception) { Response = response };
+                await OnActionExecuted(executedContext);
+
+                if (executedContext.Response != null)
+                {
+                    return executedContext.Response;
+                }
+
+                if (executedContext.Exception != null)
+                {
+                    ExceptionDispatchInfo.Capture(executedContext.Exception).Throw();
+                }
+            }
+            catch (Exception e)
+            {
+                actionContext.Response = null;
+                ExceptionDispatchInfo.Capture(e).Throw();
+            }
+
+            throw new InvalidOperationException(GetType().Name);
+        }
+
+    }
+}

CacheControl/Business/Attributes/TimeCacheControlAttribute.cs

@@ -0,0 +1,44 @@
+using System;
+using iiie.CacheControl.Attributes;
+using iiie.CacheControl.Business.OutputCache;
+using iiie.CacheControl.DBO;
+
+namespace iiie.CacheControl.Business.Attributes
+{
+    /// <summary>
+    /// A basic cache control based on time
+    /// </summary>
+    public class TimeCacheControlAttribute : CacheControlAttribute
+    {
+        /// <summary>
+        /// The number of seconds the cache is valid
+        /// </summary>
+        protected int Seconds { get; set; }
+
+        /// <summary>
+        /// Contruct a cache control based on time
+        /// </summary>
+        /// <param name="seconds">The number of seconds the cache is valid</param>
+        /// <param name="mustRevalidate">Indicates if the client can reuse cached data without asking origin server</param>
+        /// <param name="excludeQueryStringFromCacheKey">Indicates if the query string must be used to control cache</param>
+        /// <param name="cacheType">Define the cache type used to store cache</param>
+        public TimeCacheControlAttribute(int seconds, bool mustRevalidate = true,
+            bool excludeQueryStringFromCacheKey = false, OutputCacheType cacheType = OutputCacheType.Memory)
+        {
+            Seconds = seconds;
+            MustRevalidate = mustRevalidate;
+            ExcludeQueryStringFromCacheKey = excludeQueryStringFromCacheKey;
+            CacheType = cacheType;
+        }
+
+        /// <summary>
+        /// Check if data has been cached for less than Senconds seconds
+        /// </summary>
+        /// <param name="data">The cached data</param>
+        /// <returns>True if cache is still valid</returns>
+        protected override bool IsValid(CacheDbo data)
+        {
+            return data.Date.AddSeconds(Seconds) >= DateTime.Now;
+        }
+    }
+}

CacheControl/Business/CacheKey/DefaultCacheKeyGenerator.cs

@@ -0,0 +1,80 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Web.Http.Controllers;
+using iiie.CacheControl.Business.HttpExtensions;
+using iiie.CacheControl.Business.OutputCache;
+
+namespace iiie.CacheControl.Business.CacheKey
+{
+    public class DefaultCacheKeyGenerator : ICacheKeyGenerator
+    {
+        public virtual string MakeCacheKey(HttpActionContext context, MediaTypeHeaderValue mediaType, OutputCacheType cacheType, bool excludeQueryString = 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;
+
+            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('&');
+                }
+            }
+            else
+            {
+                parameters = "-" + string.Join("&", actionParameters);
+            }
+
+            if (parameters == "-") parameters = string.Empty;
+
+            var cachekey = string.Format("{0}{1}:{2}", key, 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

@@ -0,0 +1,11 @@
+using System.Net.Http.Headers;
+using System.Web.Http.Controllers;
+using iiie.CacheControl.Business.OutputCache;
+
+namespace iiie.CacheControl.Business.CacheKey
+{
+    public interface ICacheKeyGenerator
+    {
+        string MakeCacheKey(HttpActionContext context, MediaTypeHeaderValue mediaType, OutputCacheType cacheType, bool excludeQueryString = false);
+    }
+}

CacheControl/Business/HttpExtensions/CacheOutputConfiguration.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Net.Http;
+using System.Reflection;
+using System.Web.Http;
+using iiie.CacheControl.Business.CacheKey;
+using iiie.CacheControl.Business.OutputCache;
+
+namespace iiie.CacheControl.Business.HttpExtensions
+{
+    public class CacheOutputConfiguration
+    {
+        private readonly HttpConfiguration _configuration;
+
+        private OutputCacheType _cacheType;
+
+        public CacheOutputConfiguration(HttpConfiguration configuration, OutputCacheType type)
+        {
+            _configuration = configuration;
+            _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 =
+                generatorType.GetConstructor(Type.EmptyTypes) != null ||
+                generatorType.GetConstructors(BindingFlags.Instance | BindingFlags.Public)
+                .Any(x => x.GetParameters().All(p => p.IsOptional));
+            return hasEmptyOrDefaultConstructor
+                ? Activator.CreateInstance(generatorType) as ICacheKeyGenerator
+                : null;
+        }
+
+        public ICacheKeyGenerator GetCacheKeyGenerator(HttpRequestMessage request, Type generatorType)
+        {
+            generatorType = generatorType ?? typeof(ICacheKeyGenerator);
+            object cache;
+            _configuration.Properties.TryGetValue(generatorType, out cache);
+
+            var cacheFunc = cache as Func<ICacheKeyGenerator>;
+
+            var generator = cacheFunc != null
+                ? cacheFunc()
+                : request.GetDependencyScope().GetService(generatorType) as ICacheKeyGenerator;
+
+            return generator
+                ?? TryActivateCacheKeyGenerator(generatorType)
+                ?? new DefaultCacheKeyGenerator();
+        }
+
+        public IOutputCache GetCacheOutputProvider(HttpRequestMessage request)
+        {
+            object cache;
+            _configuration.Properties.TryGetValue(typeof(IOutputCache), out cache);
+
+            var cacheFunc = cache as Func<IOutputCache>;
+
+            var cacheOutputProvider = cacheFunc != null ? cacheFunc() : request.GetDependencyScope().GetService(typeof(IOutputCache)) as IOutputCache;
+            if (cacheOutputProvider == null)
+            {
+                if (_cacheType == OutputCacheType.File)
+                cacheOutputProvider = new MemoryOutputCache();
+            }
+            return cacheOutputProvider;
+        }
+    }
+}

CacheControl/Business/HttpExtensions/HttpConfigurationExtensions.cs

@@ -0,0 +1,13 @@
+using System.Web.Http;
+using iiie.CacheControl.Business.OutputCache;
+
+namespace iiie.CacheControl.Business.HttpExtensions
+{
+    public static class HttpConfigurationExtensions
+    {
+        public static CacheOutputConfiguration CacheOutputConfiguration(this HttpConfiguration config, OutputCacheType type)
+        {
+            return new CacheOutputConfiguration(config, type);
+        }
+    }
+}

CacheControl/Business/OutputCache/FileOuputCache.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+
+namespace iiie.CacheControl.Business.OutputCache
+{
+    public class FileOuputCache : IOutputCache
+    {
+        public void RemoveStartsWith(string key)
+        {
+            throw new NotImplementedException();
+        }
+
+        public T Get<T>(string key) where T : class
+        {
+            throw new NotImplementedException();
+        }
+
+        public object Get(string key)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Remove(string key)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Contains(string key)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Add(string key, object o, string dependsOnKey = null)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerable<string> AllKeys { get; private set; }
+    }
+}

CacheControl/Business/OutputCache/IOutputCache.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+
+namespace iiie.CacheControl.Business.OutputCache
+{
+    public interface IOutputCache
+    {
+        void RemoveStartsWith(string key);
+        T Get<T>(string key) where T : class;
+        object Get(string key);
+        void Remove(string key);
+        bool Contains(string key);
+        void Add(string key, object o, string dependsOnKey = null);
+        IEnumerable<string> AllKeys { get; }
+    }
+}

CacheControl/Business/OutputCache/MemoryOutputCache.cs

@@ -0,0 +1,67 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Caching;
+
+namespace iiie.CacheControl.Business.OutputCache
+{
+    public class MemoryOutputCache : IOutputCache
+    {
+        private static readonly MemoryCache Cache = MemoryCache.Default;
+
+        public void RemoveStartsWith(string key)
+        {
+            lock (Cache)
+            {
+                Cache.Remove(key);
+            }
+        }
+
+        public T Get<T>(string key) where T : class
+        {
+            var o = Cache.Get(key) as T;
+            return o;
+        }
+
+        public object Get(string key)
+        {
+            return Cache.Get(key);
+        }
+
+        public void Remove(string key)
+        {
+            lock (Cache)
+            {
+                Cache.Remove(key);
+            }
+        }
+
+        public bool Contains(string key)
+        {
+            return Cache.Contains(key);
+        }
+
+        public void Add(string key, object o, string dependsOnKey = null)
+        {
+            var cachePolicy = new CacheItemPolicy();
+
+            if (!string.IsNullOrWhiteSpace(dependsOnKey))
+            {
+                cachePolicy.ChangeMonitors.Add(
+                    Cache.CreateCacheEntryChangeMonitor(new[] { dependsOnKey })
+                );
+            }
+            lock (Cache)
+            {
+                Cache.Add(key, o, cachePolicy);
+            }
+        }
+
+        public IEnumerable<string> AllKeys
+        {
+            get
+            {
+                return Cache.Select(x => x.Key);
+            }
+        }
+    }
+}

CacheControl/Business/OutputCache/OutputCacheType.cs

@@ -0,0 +1,19 @@
+
+namespace iiie.CacheControl.Business.OutputCache
+{
+    /// <summary>
+    /// The different cache storages
+    /// </summary>
+    public enum OutputCacheType
+    {
+        /// <summary>
+        /// Cache is stored in memory
+        /// </summary>
+        Memory,
+
+        /// <summary>
+        /// Cache is stroed in a temp file
+        /// </summary>
+        File
+    }
+}

CacheControl/CacheControl.csproj

@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{BA63D177-BE9E-41E0-89F5-3D134A26A604}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>CacheControl</RootNamespace>
+    <AssemblyName>CacheControl</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Newtonsoft.Json.6.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Net.Http.Formatting, Version=5.2.3.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Microsoft.AspNet.WebApi.Client.5.2.3\lib\net45\System.Net.Http.Formatting.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Runtime.Caching" />
+    <Reference Include="System.Web.Http, Version=5.2.3.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Microsoft.AspNet.WebApi.Core.5.2.3\lib\net45\System.Web.Http.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Web.Http.WebHost, Version=5.2.3.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Microsoft.AspNet.WebApi.WebHost.5.2.3\lib\net45\System.Web.Http.WebHost.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Business\Attributes\CacheControlAttribute.cs" />
+    <Compile Include="Business\Attributes\TimeCacheControlAttribute.cs" />
+    <Compile Include="Business\CacheKey\DefaultCacheKeyGenerator.cs" />
+    <Compile Include="Business\CacheKey\ICacheKeyGenerator.cs" />
+    <Compile Include="Business\HttpExtensions\CacheOutputConfiguration.cs" />
+    <Compile Include="Business\HttpExtensions\HttpConfigurationExtensions.cs" />
+    <Compile Include="Business\OutputCache\FileOuputCache.cs" />
+    <Compile Include="Business\OutputCache\IOutputCache.cs" />
+    <Compile Include="Business\OutputCache\MemoryOutputCache.cs" />
+    <Compile Include="Business\OutputCache\OutputCacheType.cs" />
+    <Compile Include="DBO\CacheDbo.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

CacheControl/DBO/CacheDBO.cs

@@ -0,0 +1,30 @@
+using System;
+
+namespace iiie.CacheControl.DBO
+{
+    /// <summary>
+    /// Basic fields for data to be cached
+    /// </summary>
+    public class CacheDbo
+    {
+        /// <summary>
+        /// The content type of the data
+        /// </summary>
+        public string ContentType { get; set; }
+
+        /// <summary>
+        /// The data itself
+        /// </summary>
+        public byte[] Content { get; set; }
+
+        /// <summary>
+        /// The e tag to identify cache
+        /// </summary>
+        public string ETag { get; set; }
+
+        /// <summary>
+        /// The date to data was first cached
+        /// </summary>
+        public DateTime Date { get; set; }
+    }
+}

CacheControl/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("CacheControl")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("CacheControl")]
+[assembly: AssemblyCopyright("Copyright ©  2015")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("087758c5-539f-49d1-b9e9-771f42697459")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

CacheControl/packages.config

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Microsoft.AspNet.WebApi" version="5.2.3" targetFramework="net45" />
+  <package id="Microsoft.AspNet.WebApi.Client" version="5.2.3" targetFramework="net45" />
+  <package id="Microsoft.AspNet.WebApi.Core" version="5.2.3" targetFramework="net45" />
+  <package id="Microsoft.AspNet.WebApi.WebHost" version="5.2.3" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="6.0.8" targetFramework="net45" />
+</packages>

NuGet-3ie.sln

@@ -5,6 +5,8 @@ VisualStudioVersion = 12.0.21005.1
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NuGet-server", "NuGet-server\NuGet-server.csproj", "{23F13185-BFE0-435A-8772-36DA53DA5BDA}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CacheControl", "CacheControl\CacheControl.csproj", "{BA63D177-BE9E-41E0-89F5-3D134A26A604}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -15,6 +17,10 @@ Global
 		{23F13185-BFE0-435A-8772-36DA53DA5BDA}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{23F13185-BFE0-435A-8772-36DA53DA5BDA}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{23F13185-BFE0-435A-8772-36DA53DA5BDA}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BA63D177-BE9E-41E0-89F5-3D134A26A604}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BA63D177-BE9E-41E0-89F5-3D134A26A604}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BA63D177-BE9E-41E0-89F5-3D134A26A604}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BA63D177-BE9E-41E0-89F5-3D134A26A604}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

NuGet-server/NuGet-server.csproj

@@ -100,6 +100,7 @@
   </ItemGroup>
   <ItemGroup>
     <Content Include="packages.config" />
+    <None Include="Properties\PublishProfiles\nuget.pubxml" />
     <None Include="Web.Debug.config">
       <DependentUpon>Web.config</DependentUpon>
     </None>