public static IList<CategoryInfo> GetCategories() {    Category cat = new Category();    if (!enableCaching)        return cat.GetCategories();    string key = "category_all";    IList<CategoryInfo> data = http://www.mamicode.com/(IList<CategoryInfo>)HttpRuntime.Cache[key];    // Check if the data exists in the data cache    if (data =http://www.mamicode.com/= null) {        // If the data is not in the cache then fetch the data from the business logic tier        data = http://www.mamicode.com/cat.GetCategories();"color: green;">// Create a AggregateCacheDependency object from the factory        AggregateCacheDependency cd = DependencyFacade.GetCategoryDependency();        // Store the output in the data cache, and Add the necessary AggregateCacheDependency object        HttpRuntime.Cache.Add(key, data, cd, DateTime.Now.AddHours(categoryTimeout), Cache.NoSlidingExpiration, CacheItemPriority.High, null);    }    return data;}

<?xml version="1.0" encoding="utf-8" ?><configuration>  <configSections>    <section name="unity"             type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,              Microsoft.Practices.Unity.Configuration"/>    <section name="cachingConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Caching.Configuration.CacheManagerSettings, Microsoft.Practices.EnterpriseLibrary.Caching, Version=5.0.414.0, Culture=neutral, PublicKeyToken=null" />  </configSections>  <startup>    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />  </startup>  <cachingConfiguration defaultCacheManager="ByteartRetailCacheManager">    <cacheManagers>      <add name="ByteartRetailCacheManager" type="Microsoft.Practices.EnterpriseLibrary.Caching.CacheManager, Microsoft.Practices.EnterpriseLibrary.Caching, Version=5.0.414.0, Culture=neutral, PublicKeyToken=null" expirationPollFrequencyInSeconds="60" maximumElementsInCacheBeforeScavenging="1000" numberToRemoveWhenScavenging="10" backingStoreName="NullBackingStore" />      <!--          expirationPollFrequencyInSeconds:多少秒进行一次过期检查，缺省值60秒 是检查，跟过期时间没有关系          maximumElementsInCacheBeforeScavenging:缓冲中的最大元素数量          numberToRemoveWhenScavenging：一次移除的数量      -->    </cacheManagers>    <backingStores>      <add type="Microsoft.Practices.EnterpriseLibrary.Caching.BackingStoreImplementations.NullBackingStore, Microsoft.Practices.EnterpriseLibrary.Caching, Version=5.0.414.0, Culture=neutral, PublicKeyToken=null"        name="NullBackingStore" />    </backingStores>  </cachingConfiguration>    <!--BEGIN: Unity-->  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">    <sectionExtension type="Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension, Microsoft.Practices.Unity.Interception.Configuration"/>    <container>      <extension type="Interception"/>      <!--type=命名空间.接口，命名空间 mapTo=命名空间.对象，命名空间-->      <register type="MvcApplication1.ITalk, MvcApplication1" mapTo="MvcApplication1.Talk, MvcApplication1">        <interceptor type="InterfaceInterceptor"/>        <interceptionBehavior type="MvcApplication1.CachingBehavior, MvcApplication1"/>        <interceptionBehavior type="MvcApplication1.ExceptionLoggingBehavior, MvcApplication1"/>      </register>    </container>  </unity>  <!--END: Unity--></configuration>

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace MvcApplication1{    /// <summary>    /// 表示由此特性所描述的方法，能够获得来自基础结构层所提供的缓存功能。    /// </summary>    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]    public class CachingAttribute : Attribute    {        #region Ctor        /// <summary>        /// 初始化一个新的<c>CachingAttribute</c>类型。        /// </summary>        /// <param name="method">缓存方式。</param>        public CachingAttribute(CachingMethod method)        {            this.Method = method;        }        /// <summary>        /// 初始化一个新的<c>CachingAttribute</c>类型。        /// </summary>        /// <param name="method">缓存方式</param>        /// <param name="TimeOutSeconds">设置超时时间(秒)</param>        public CachingAttribute(CachingMethod method, int TimeOutSeconds)            : this(method)        {            this.TimeOutSeconds = TimeOutSeconds;        }        /// <summary>        /// 初始化一个新的<c>CachingAttribute</c>类型。        /// </summary>        /// <param name="method">缓存方式。</param>        /// <param name="correspondingMethodNames">        /// 与当前缓存方式相关的方法名称。注：此参数仅在缓存方式为Remove时起作用。        /// </param>        public CachingAttribute(CachingMethod method, params string[] correspondingMethodNames)            : this(method)        {            this.CorrespondingMethodNames = correspondingMethodNames;        }        #endregion        #region Public Properties        /// <summary>        /// 设置缓存的超时时间        /// </summary>        public int TimeOutSeconds { get; set; }        /// <summary>        /// 获取或设置缓存方式。        /// </summary>        public CachingMethod Method { get; set; }        /// <summary>        /// 获取或设置一个<see cref="Boolean"/>值，该值表示当缓存方式为Put时，是否强制将值写入缓存中。        /// </summary>        public bool Force { get; set; }        /// <summary>        /// 获取或设置与当前缓存方式相关的方法名称。注：此参数仅在缓存方式为Remove时起作用。        /// </summary>        public string[] CorrespondingMethodNames { get; set; }        #endregion    }

public enum CachingMethod    {        Remove=0,        Get=1,        Put = 2    } 

}

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace MvcApplication1{    public interface ICacheProvider    {        #region Methods        /// <summary>        /// 向缓存中添加一个对象。        /// </summary>        /// <param name="key">缓存的键值，该值通常是使用缓存机制的方法的名称。</param>        /// <param name="valKey">缓存值的键值，该值通常是由使用缓存机制的方法的参数值所产生。</param>        /// <param name="value">需要缓存的对象。</param>        void Add(string key, string valKey, object value, int TimeoutSeconds);        /// <summary>        /// 向缓存中更新一个对象。        /// </summary>        /// <param name="key">缓存的键值，该值通常是使用缓存机制的方法的名称。</param>        /// <param name="valKey">缓存值的键值，该值通常是由使用缓存机制的方法的参数值所产生。</param>        /// <param name="value">需要缓存的对象。</param>        void Put(string key, string valKey, object value);        /// <summary>        /// 从缓存中读取对象。        /// </summary>        /// <param name="key">缓存的键值，该值通常是使用缓存机制的方法的名称。</param>        /// <param name="valKey">缓存值的键值，该值通常是由使用缓存机制的方法的参数值所产生。</param>        /// <returns>被缓存的对象。</returns>        object Get(string key, string valKey);        /// <summary>        /// 从缓存中移除对象。        /// </summary>        /// <param name="key">缓存的键值，该值通常是使用缓存机制的方法的名称。</param>        void Remove(string key);        /// <summary>        /// 获取一个<see cref="Boolean"/>值，该值表示拥有指定键值的缓存是否存在。        /// </summary>        /// <param name="key">指定的键值。</param>        /// <returns>如果缓存存在，则返回true，否则返回false。</returns>        bool Exists(string key);        /// <summary>        /// 获取一个<see cref="Boolean"/>值，该值表示拥有指定键值和缓存值键的缓存是否存在。        /// </summary>        /// <param name="key">指定的键值。</param>        /// <param name="valKey">缓存值键。</param>        /// <returns>如果缓存存在，则返回true，否则返回false。</returns>        bool Exists(string key, string valKey);        #endregion    }}

using Microsoft.Practices.EnterpriseLibrary.Caching;using Microsoft.Practices.Unity.InterceptionExtension;using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace MvcApplication1{    public class CachingBehavior : IInterceptionBehavior    {        public IEnumerable<Type> GetRequiredInterfaces()        {            return Type.EmptyTypes;        }        #region Private Methods        /// <summary>        /// 根据指定的<see cref="CachingAttribute"/>以及<see cref="IMethodInvocation"/>实例，        /// 获取与某一特定参数值相关的键名。        /// </summary>        /// <param name="cachingAttribute"><see cref="CachingAttribute"/>实例。</param>        /// <param name="input"><see cref="IMethodInvocation"/>实例。</param>        /// <returns>与某一特定参数值相关的键名。        ///   <remarks>        ///    例如：<see cref="ICacheProvider.Add"/>        ///   </remarks>        /// </returns>        private string GetValueKey(CachingAttribute cachingAttribute, IMethodInvocation input)        {            switch (cachingAttribute.Method)            {                // 如果是Remove，则不存在特定值键名，所有的以该方法名称相关的缓存都需要清除                case CachingMethod.Remove:                    return null;                // 如果是Get或者Put，则需要产生一个针对特定参数值的键名                case CachingMethod.Get:                case CachingMethod.Put:                    if (input.Arguments != null &&                        input.Arguments.Count > 0)                    {                        var sb = new StringBuilder();                        for (int i = 0; i < input.Arguments.Count; i++)                        {                            sb.Append(input.Arguments[i].ToString());                            if (i != input.Arguments.Count - 1)                                sb.Append("_");                        }                        return sb.ToString();                    }                    else                        return "NULL";                default:                    throw new InvalidOperationException("无效的缓存方式。");            }        }        #endregion        public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext)        {            var method = input.MethodBase;            var key = method.Name;            if (method.IsDefined(typeof(CachingAttribute), false))            {                var cachingAttribute = (CachingAttribute)method.GetCustomAttributes(typeof(CachingAttribute), false)[0];                var valKey = GetValueKey(cachingAttribute, input);                switch (cachingAttribute.Method)                {                    case CachingMethod.Get:                        try                        {                            if (CacheManager.Instance.Exists(key, valKey))                            {                                var obj = CacheManager.Instance.Get(key, valKey);                                obj += "缓存";                                var arguments = new object[input.Arguments.Count];                                input.Arguments.CopyTo(arguments, 0);                                return new VirtualMethodReturn(input, obj, arguments);                            }                            else                            {                                var methodReturn = getNext().Invoke(input, getNext);                                if (cachingAttribute.TimeOutSeconds > 0)                                {                                    CacheManager.Instance.Add(key, valKey, methodReturn.ReturnValue, cachingAttribute.TimeOutSeconds);                                }                                else                                {                                    CacheManager.Instance.Add(key, valKey, methodReturn.ReturnValue);                                }                                return methodReturn;                            }                        }                        catch (Exception ex)                        {                            return new VirtualMethodReturn(input, ex);                        }                    case CachingMethod.Put:                        try                        {                            var methodReturn = getNext().Invoke(input, getNext);                            if (CacheManager.Instance.Exists(key))                            {                                if (cachingAttribute.Force)                                {                                    CacheManager.Instance.Remove(key);                                    if (cachingAttribute.TimeOutSeconds > 0)                                    {                                        CacheManager.Instance.Add(key, valKey, methodReturn.ReturnValue, cachingAttribute.TimeOutSeconds);                                    }                                    else                                    {                                        CacheManager.Instance.Add(key, valKey, methodReturn.ReturnValue);                                    }                                }                                else                                {                                    if (cachingAttribute.TimeOutSeconds > 0)                                    {                                        CacheManager.Instance.Add(key, valKey, methodReturn.ReturnValue, cachingAttribute.TimeOutSeconds);                                    }                                    else                                    {                                        CacheManager.Instance.Add(key, valKey, methodReturn.ReturnValue);                                    }                                }                            }                            else                            {                                if (cachingAttribute.TimeOutSeconds > 0)                                {                                    CacheManager.Instance.Add(key, valKey, methodReturn.ReturnValue, cachingAttribute.TimeOutSeconds);                                }                                else                                {                                    CacheManager.Instance.Add(key, valKey, methodReturn.ReturnValue);                                }                            }                            return methodReturn;                        }                        catch (Exception ex)                        {                            return new VirtualMethodReturn(input, ex);                        }                    case CachingMethod.Remove:                        try                        {                            var removeKeys = cachingAttribute.CorrespondingMethodNames;                            foreach (var removeKey in removeKeys)                            {                                if (CacheManager.Instance.Exists(removeKey))                                    CacheManager.Instance.Remove(removeKey);                            }                            var methodReturn = getNext().Invoke(input, getNext);                            return methodReturn;                        }                        catch (Exception ex)                        {                            return new VirtualMethodReturn(input, ex);                        }                    default: break;                }            }            Console.WriteLine("CachingBehavior");            return getNext().Invoke(input, getNext);        }        public bool WillExecute        {            get { return true; }        }    }}

using Microsoft.Practices.Unity.InterceptionExtension;using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace MvcApplication1{    public class ExceptionLoggingBehavior : IInterceptionBehavior    {        public IEnumerable<Type> GetRequiredInterfaces()        {            return Type.EmptyTypes;        }        public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext)        {            Console.WriteLine("ExceptionLoggingBehavior");            return getNext().Invoke(input, getNext);        }        public bool WillExecute        {            get { return true; }        }    }}

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace MvcApplication1{    public sealed class CacheManager : ICacheProvider    {        #region Private Fields        private readonly ICacheProvider _cacheProvider;        private static readonly CacheManager _instance = new CacheManager();        #endregion        #region Ctor        static CacheManager() { }        private CacheManager()        {            _cacheProvider = new EntLibCacheProvider();        }        #endregion        #region Public Properties        /// <summary>        /// 获取<c>CacheManager</c>类型的单件（Singleton）实例。        /// </summary>        public static CacheManager Instance        {            get { return _instance; }        }        #endregion        #region ICacheProvider Members        /// <summary>        /// 向缓存中添加一个对象。        /// </summary>        /// <param name="key">缓存的键值，该值通常是使用缓存机制的方法的名称。</param>        /// <param name="valKey">缓存值的键值，该值通常是由使用缓存机制的方法的参数值所产生。</param>        /// <param name="value">需要缓存的对象。</param>        public void Add(string key, string valKey, object value, int Timeoutseconds=60)        {            _cacheProvider.Add(key, valKey, value,Timeoutseconds);        }        /// <summary>        /// 向缓存中更新一个对象。        /// </summary>        /// <param name="key">缓存的键值，该值通常是使用缓存机制的方法的名称。</param>        /// <param name="valKey">缓存值的键值，该值通常是由使用缓存机制的方法的参数值所产生。</param>        /// <param name="value">需要缓存的对象。</param>        public void Put(string key, string valKey, object value)        {            _cacheProvider.Put(key, valKey, value);        }        /// <summary>        /// 从缓存中读取对象。        /// </summary>        /// <param name="key">缓存的键值，该值通常是使用缓存机制的方法的名称。</param>        /// <param name="valKey">缓存值的键值，该值通常是由使用缓存机制的方法的参数值所产生。</param>        /// <returns>被缓存的对象。</returns>        public object Get(string key, string valKey)        {            return _cacheProvider.Get(key, valKey);        }        /// <summary>        /// 从缓存中移除对象。        /// </summary>        /// <param name="key">缓存的键值，该值通常是使用缓存机制的方法的名称。</param>        public void Remove(string key)        {            _cacheProvider.Remove(key);        }        /// <summary>        /// 获取一个<see cref="Boolean"/>值，该值表示拥有指定键值的缓存是否存在。        /// </summary>        /// <param name="key">指定的键值。</param>        /// <returns>如果缓存存在，则返回true，否则返回false。</returns>        public bool Exists(string key)        {            return _cacheProvider.Exists(key);        }        /// <summary>        /// 获取一个<see cref="Boolean"/>值，该值表示拥有指定键值和缓存值键的缓存是否存在。        /// </summary>        /// <param name="key">指定的键值。</param>        /// <param name="valKey">缓存值键。</param>        /// <returns>如果缓存存在，则返回true，否则返回false。</returns>        public bool Exists(string key, string valKey)        {            return _cacheProvider.Exists(key, valKey);        }        #endregion    }}

using Microsoft.Practices.EnterpriseLibrary.Caching;using Microsoft.Practices.EnterpriseLibrary.Caching.Expirations;using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace MvcApplication1{    public class EntLibCacheProvider : ICacheProvider    {        #region Private Fields        private readonly ICacheManager _cacheManager = CacheFactory.GetCacheManager();                #endregion        #region ICacheProvider Members        /// <summary>        /// 向缓存中添加一个对象。        /// </summary>        /// <param name="key">缓存的键值，该值通常是使用缓存机制的方法的名称。</param>        /// <param name="valKey">缓存值的键值，该值通常是由使用缓存机制的方法的参数值所产生。</param>        /// <param name="value">需要缓存的对象。</param>        public void Add(string key, string valKey, object value,int Timeoutseconds)        {            Dictionary<string, object> dict = null;            if (_cacheManager.Contains(key))            {                dict = (Dictionary<string, object>)_cacheManager[key];                dict[valKey] = value;            }            else            {                dict = new Dictionary<string, object>();                dict.Add(valKey, value);            }            AbsoluteTime expiry = new AbsoluteTime(new TimeSpan(0, 0, 0, Timeoutseconds));            _cacheManager.Add(key, dict, CacheItemPriority.High,null, new ICacheItemExpiration[] { expiry });        }        /// <summary>        /// 向缓存中更新一个对象。        /// </summary>        /// <param name="key">缓存的键值，该值通常是使用缓存机制的方法的名称。</param>        /// <param name="valKey">缓存值的键值，该值通常是由使用缓存机制的方法的参数值所产生。</param>        /// <param name="value">需要缓存的对象。</param>        public void Put(string key, string valKey, object value)        {            Add(key, valKey, value,60);        }        /// <summary>        /// 从缓存中读取对象。        /// </summary>        /// <param name="key">缓存的键值，该值通常是使用缓存机制的方法的名称。</param>        /// <param name="valKey">缓存值的键值，该值通常是由使用缓存机制的方法的参数值所产生。</param>        /// <returns>被缓存的对象。</returns>        public object Get(string key, string valKey)        {            if (_cacheManager.Contains(key))            {                Dictionary<string, object> dict = (Dictionary<string, object>)_cacheManager[key];                if (dict != null && dict.ContainsKey(valKey))                    return dict[valKey];                else                    return null;            }            return null;        }        /// <summary>        /// 从缓存中移除对象。        /// </summary>        /// <param name="key">缓存的键值，该值通常是使用缓存机制的方法的名称。</param>        public void Remove(string key)        {            _cacheManager.Remove(key);        }        /// <summary>        /// 获取一个<see cref="Boolean"/>值，该值表示拥有指定键值的缓存是否存在。        /// </summary>        /// <param name="key">指定的键值。</param>        /// <returns>如果缓存存在，则返回true，否则返回false。</returns>        public bool Exists(string key)        {            if (!_cacheManager.Contains(key))                return false;            if (_cacheManager[key] == null || (Dictionary<string, object>)_cacheManager[key] == null)                return false;            return true;        }        /// <summary>        /// 获取一个<see cref="Boolean"/>值，该值表示拥有指定键值和缓存值键的缓存是否存在。        /// </summary>        /// <param name="key">指定的键值。</param>        /// <param name="valKey">缓存值键。</param>        /// <returns>如果缓存存在，则返回true，否则返回false。</returns>        public bool Exists(string key, string valKey)        {            if (!_cacheManager.Contains(key))                return false;            if (_cacheManager[key] == null || (Dictionary<string, object>)_cacheManager[key] == null)                return false;            return _cacheManager.Contains(key) &&                ((Dictionary<string, object>)_cacheManager[key]).ContainsKey(valKey);        }        #endregion    }}

using Microsoft.Practices.Unity;using Microsoft.Practices.Unity.Configuration;using System;using System.Collections.Generic;using System.Configuration;using System.Linq;using System.Reflection;using System.Text;using System.Threading.Tasks;namespace MvcApplication1{    public sealed class ServiceLocator : IServiceProvider    {        #region Private Fields        private readonly IUnityContainer container;        #endregion        #region Private Static Fields        private static readonly ServiceLocator instance = new ServiceLocator();        #endregion        #region Ctor        /// <summary>        /// Initializes a new instance of <c>ServiceLocator</c> class.        /// </summary>        private ServiceLocator()        {            UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");            container = new UnityContainer();            section.Configure(container);        }        #endregion        #region Public Static Properties        /// <summary>        /// Gets the singleton instance of the <c>ServiceLocator</c> class.        /// </summary>        public static ServiceLocator Instance        {            get { return instance; }        }        #endregion        #region Private Methods        private IEnumerable<ParameterOverride> GetParameterOverrides(object overridedArguments)        {            List<ParameterOverride> overrides = new List<ParameterOverride>();            Type argumentsType = overridedArguments.GetType();            argumentsType.GetProperties(BindingFlags.Public | BindingFlags.Instance)                .ToList()                .ForEach(property =>                {                    var propertyValue = http://www.mamicode.com/property.GetValue(overridedArguments, null);                    var propertyName = property.Name;                    overrides.Add(new ParameterOverride(propertyName, propertyValue));                });            return overrides;        }        #endregion        #region Public Methods        /// <summary>        /// Gets the service instance with the given type.        /// </summary>        /// <typeparam name="T">The type of the service.</typeparam>        /// <returns>The service instance.</returns>        public T GetService<T>()        {            return container.Resolve<T>();        }        /// <summary>        /// Gets the service instance with the given type by using the overrided arguments.        /// </summary>        /// <typeparam name="T">The type of the service.</typeparam>        /// <param name="overridedArguments">The overrided arguments.</param>        /// <returns>The service instance.</returns>        public T GetService<T>(object overridedArguments)        {            var overrides = GetParameterOverrides(overridedArguments);            return container.Resolve<T>(overrides.ToArray());        }        /// <summary>        /// Gets the service instance with the given type by using the overrided arguments.        /// </summary>        /// <param name="serviceType">The type of the service.</param>        /// <param name="overridedArguments">The overrided arguments.</param>        /// <returns>The service instance.</returns>        public object GetService(Type serviceType, object overridedArguments)        {            var overrides = GetParameterOverrides(overridedArguments);            return container.Resolve(serviceType, overrides.ToArray());        }        #endregion        #region IServiceProvider Members        /// <summary>        /// Gets the service instance with the given type.        /// </summary>        /// <param name="serviceType">The type of the service.</param>        /// <returns>The service instance.</returns>        public object GetService(Type serviceType)        {            return container.Resolve(serviceType);        }        #endregion    }}

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace MvcApplication1{    public class Talk : ITalk    {        public string Speak(string msg)        {            return msg;        }    }    public interface ITalk    {        [Caching(CachingMethod.Get)]        string Speak(string msg);    }}

         ITalk talk = ServiceLocator.Instance.GetService<ITalk>();            string s = talk.Speak("正常调用");            string s1 = talk.Speak("正常调用");            ViewBag.Message = s +"_"+ s1;