帮我写个Cache帮助类，通用的

[hxk62449345]

HttpRuntime.Cache?
帮我写个

[种草德鲁伊]

绝对通用。

static Dictionary<object, object> cache = new Dictionary<object, object>();

[starry]

/// Cache操作类
/// <summary>
/// Cache操作类
/// </summary>
public static class CacheCustom
{
/// <summary>
/// 简单创建/修改Cache，前提是这个值是字符串形式的
/// </summary>
/// <param name="strCacheName">Cache名称</param>
/// <param name="strValue">Cache值</param>
/// <param name="iExpires">有效期，秒数（使用的是当前时间+秒数得到一个绝对到期值）</param>
/// <param name="priority">保留优先级，1最不会被清除，6最容易被内存管理清除（1:NotRemovable；2:High；3:AboveNormal；4:Normal；5:BelowNormal；6:Low）</param>
public static void Insert(string strCacheName, string strValue, int iExpires, int priority)
{
TimeSpan ts = new TimeSpan(0, 0, iExpires);
CacheItemPriority cachePriority;
switch (priority)
{
case 6:
cachePriority = CacheItemPriority.Low;
break;
case 5:
cachePriority = CacheItemPriority.BelowNormal;
break;
case 4:
cachePriority = CacheItemPriority.Normal;
break;
case 3:
cachePriority = CacheItemPriority.AboveNormal;
break;
case 2:
cachePriority = CacheItemPriority.High;
break;
case 1:
cachePriority = CacheItemPriority.NotRemovable;
break;
default:
cachePriority = CacheItemPriority.Default;
break;
}
HttpContext.Current.Cache.Insert(strCacheName, strValue, null, DateTime.Now.Add(ts), System.Web.Caching.Cache.NoSlidingExpiration, cachePriority, null);
}

/// <summary>
/// 获取Cache对象的值，前提是这个值是字符串形式的
/// </summary>
/// <param name="strCacheName">Cache名称</param>
/// <returns>Cache字符串值</returns>
public static string Get(string strCacheName)
{
return HttpContext.Current.Cache[strCacheName].ToString();
}

/// 删除Cache对象
/// <summary>
/// 删除Cache对象
/// </summary>
/// <param name="strCacheName">Cache名称</param>
public static void Del(string strCacheName)
{
HttpContext.Current.Cache.Remove(strCacheName);
}
}

[starry]

先用着吧，功能还行

[hxk62449345]

[Quote=引用 1 楼 karascanvas 的回复:]
绝对通用。

static Dictionary<object, object> cache = new Dictionary<object, object>();
[/Quote]
是用全局静态还是用asp.net的Cache对象？

[starry]

汗，你要的到底是静态全局对象，还是.net里面的缓存池对象啊？

[huangwenquan123]

http://licheng3222.blog.163.com/blog/static/610993672008106104158249/

[LMAOhuaNL]

object类型就可以通用

[子夜__]

CacheHelper

[kkbac]

发一个自己用的, 通用性不高.应该够用了.

using System;
using System.Runtime.Caching;

namespace Kkbac.Tools
{
    public class Caches
    {
        /// <summary>
        /// 3600 * 24
        /// </summary>
        private static long _maxSeconds = 3600 * 24;
        /// <summary>
        /// 获取指定的缓存
        /// </summary>
        /// <param name="key">Cache的名称</param>
        /// <returns></returns>
        public static object Get(string key)
        {
            if (string.IsNullOrEmpty(key))
            {
                return null;
            }
            MemoryCache cache = MemoryCache.Default;
            return cache.Get(key);
             
        }

        /// <summary>
        /// 返回指定的缓存,如果不存在就用函数返回的值,自动加入缓存.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="fun"></param>
        /// <returns></returns>
        public static T Get<T>(string key, Func<T> fun, long seconds = 1800)
        {
            T t;
            object o = Get(key);
            if (o != null && o is T)
            {
                t = (T)o;
            }
            else
            {
                t = fun();
                Set(key, t, seconds);
            }
            return t;
        }

        /// <summary>
        /// 删除指定的缓存
        /// </summary>
        /// <param name="key">Cache的名称</param>
        public static void Remove(string key)
        {
            if (string.IsNullOrEmpty(key))
            {
                return;
            }
            MemoryCache cache = MemoryCache.Default;
            cache.Remove(key);
        }

        /// <summary>
        /// 设置Cache的值,过期时间:到时间绝对过期. 时间秒.
        /// </summary>
        /// <param name="key">Cache的名称</param>
        /// <param name="value">Cache的值</param>
        /// <param name="seconds">过期时间,相对当前时间: 秒. 默认:1800</param>        
        public static void Set(string key, object value, long seconds = 1800)
        {
            if (value == null || string.IsNullOrEmpty(key))
            {
                return;
            }
            MemoryCache cache = MemoryCache.Default;
            if (seconds < 1)
            {
                seconds = _maxSeconds;
            }
            cache.Set(key, value, DateTimeOffset.UtcNow.AddSeconds(seconds));
        }

    }
}

[todayclock]

/// <summary>
    /// 全局缓存类
    /// </summary>
    /// <example><code>
    /// 使用示例：
    /// 实例化： CacheManage cache=CacheManage.Instance;
    /// 添加：   cache.Add("路过秋天",new MDataTable);
    /// 判断：   if(cache.Contains("路过秋天"))
    ///          {
    /// 获取：       MDataTable table=cache.Get("路过秋天") as MDataTable;
    ///          }
    /// </code></example>
    public class CacheManage
    {
        private readonly System.Web.HttpContext H = new System.Web.HttpContext(new System.Web.HttpRequest("Null.File", "http://cyq1162.cnblogs.com", String.Empty), new System.Web.HttpResponse(null));
        private System.Web.Caching.Cache theCache = null;
        private Dictionary<string, CacheDependencyInfo> cacheState = new Dictionary<string, CacheDependencyInfo>();
        private CacheManage()
        {
            theCache = H.Cache;
        }
        /// <summary>
        /// 获和缓存总数
        /// </summary>
        public int Count
        {
            get
            {
                return theCache == null ? 0 : theCache.Count;
            }
        }
        /// <summary>
        /// 返回唯一实例
        /// </summary>
        public static CacheManage Instance
        {
            get
            {
                return Shell.instance;
            }
        }

        class Shell
        {
            internal static readonly CacheManage instance = new CacheManage();
        }

        /// <summary>
        /// 获得一个Cache对象
        /// </summary>
        /// <param name="key">标识</param>
        /// <returns></returns>
        public object Get(string key)
        {
            if (Contains(key))
            {
                return theCache[key];
            }
            return null;
        }
        /// <summary>
        /// 是否存在缓存
        /// </summary>
        /// <param name="key">标识</param>
        /// <returns></returns>
        public bool Contains(string key)
        {
            return theCache != null && theCache[key] != null;
        }
        /// <summary>
        /// 添加一个Cache对象
        /// </summary>
        /// <param name="key">标识</param>
        /// <param name="value">对象值</param>
        public void Add(string key, object value)
        {
            Add(key, value, null);
        }
        public void Add(string key, object value, string filePath)
        {
            if (!Contains(key))
            {
                Add(key, value, filePath,0);//再插入Cache
            }
        }
        public void Add(string key, object value, string filePath, double cacheTimeMinutes)
        {
            if (!Contains(key))
            {
                Insert(key, value, filePath, cacheTimeMinutes);//再插入Cache
            }
        }
        /// <summary>
        /// 相对底层Cache添加方法,添加一个Cache请用Add方法
        /// </summary>
        /// <param name="key">标识</param>
        /// <param name="value">对象值</param>
        /// <param name="filePath">文件依赖路径</param>
        private void Insert(string key, object value, string filePath, double cacheTimeMinutes)
        {
            CacheDependency theCacheDependency=null;
            if (!string.IsNullOrEmpty(filePath))
            {
                theCacheDependency = new CacheDependency(filePath);
            }
            double cacheTime = cacheTimeMinutes;
            if (cacheTimeMinutes == 0)
            {
                cacheTime = AppConfig.CacheTime;
            }
            theCache.Insert(key, value, theCacheDependency, DateTime.Now.AddMinutes(cacheTime == 0 ? 20 : cacheTime), TimeSpan.Zero, CacheItemPriority.Default, null);
            if (cacheState.ContainsKey(key))
            {
                cacheState.Remove(key);
            }
            CacheDependencyInfo info = new CacheDependencyInfo(theCacheDependency);
            cacheState.Add(key, info);
        }

        /// <summary>
        /// 删除一个Cache对象
        /// </summary>
        /// <param name="key">标识</param>
        public void Remove(string key)
        {
            if (Contains(key))
            {
                theCache.Remove(key);
                cacheState.Remove(key);
            }
        }

        /// <summary>
        /// 用户手动设置缓存对象已更改
        /// </summary>
        /// <param name="key"></param>
        /// <param name="change"></param>
        public void SetChange(string key,bool change)
        {
            if (cacheState.ContainsKey(key) && Contains(key))
            {
                CacheDependencyInfo info = cacheState[key];
                if (info != null)
                {
                    info.UserSetChange(change);
                }
            }
        }
        /// <summary>
        /// 获取缓存对象是否已更改
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool GetHasChanged(string key)
        {
            if (cacheState.ContainsKey(key) && Contains(key))
            {
                CacheDependencyInfo info = cacheState[key];
                if (info != null)
                {
                    return info.IsChanged?false:info.UserChange ;
                }
            }
            return false;
        }
    }
    /// <summary>
    /// 缓存依赖信息
    /// </summary>
    internal class CacheDependencyInfo
    {
        public CacheDependencyInfo(CacheDependency dependency)
        {
            if (dependency != null)
            {
                FileDependency = dependency;
                CacheChangeTime = FileDependency.UtcLastModified;
            }
        }
        /// <summary>
        /// 系统文件依赖是否发生改变
        /// </summary>
        public bool IsChanged
        {
            get
            {
                if (FileDependency!=null && (FileDependency.HasChanged || CacheChangeTime != FileDependency.UtcLastModified))
                {
                    CacheChangeTime = FileDependency.UtcLastModified;
                    return true;
                }
                return false;
            }
        }
        CacheDependency FileDependency = null;
        public bool UserChange= false;
        DateTime CacheChangeTime=DateTime.MinValue;
        public void UserSetChange(bool change)
        {
            UserChange = IsChanged ? false : change;
        }
    }

[hxk62449345]

够用了。！