缓存处理类(MemoryCache结合文件缓存)

想提升站点的性能,于是增加了缓存,但是站点不会太大,于是不会到分布式memcached的缓存和redis这个nosql库,于是自己封装了.NET内置的缓存组件

原先使用System.Web.Caching.Cache,但是asp.net会在System.Web.Caching.Cache缓存页面等数据,于是替换了System.Web.Caching.Cache为MemoryCache。

而在使用MemoryCache的时候,重新启动网站会丢失缓存,于是加了自己的扩展,将缓存序列化存放在文件内,在缓存丢的时候从文件内获取缓存,做了简易的扩展。(现在应用在我的Cactus里面)

using System;
using System.Collections;
using System.Web;
using System.Text;
using System.IO;
using System.Runtime.Caching;
using System.Diagnostics;
using System.Runtime.Serialization.Formatters.Binary;
using System.Configuration;
using System.Collections.Generic;

namespace Cactus.Common
{
    /// <summary>
    /// 缓存对象数据结构
    /// </summary>
    [Serializable()]
    public class CacheData{
        public object Value { get;set;}
        public DateTime CreateTime { get; set; }
        public DateTimeOffset AbsoluteExpiration { get; set; }
        public DateTime FailureTime { get
        { if (AbsoluteExpiration == System.Runtime.Caching.ObjectCache.InfiniteAbsoluteExpiration)
            {
                return AbsoluteExpiration.DateTime;
            }
            else { return CreateTime.AddTicks(AbsoluteExpiration.Ticks); } }
        }
        public CacheItemPriority Priority { get; set; }
    }

    /// <summary>
    /// 缓存处理类(MemoryCache)
    /// </summary>
    public class CacheHelper
    {
        //在应用程序的同级目录(主要防止外部访问)
        public static string filePath = Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory + ConfigurationManager.ConnectionStrings["filecache"].ConnectionString);
        //文件扩展名
        public static string fileExt = ".cache";
        /// <summary>
        /// 获取数据缓存
        /// </summary>
        /// <param name="cacheKey">键</param>
        public static object GetCache(string cacheKey)
        {
            //System.Web.Caching.Cache objCache = HttpRuntime.Cache;
            //return objCache[cacheKey];
            long i=System.Runtime.Caching.MemoryCache.Default.GetCount();
            CacheItem objCache=System.Runtime.Caching.MemoryCache.Default.GetCacheItem(cacheKey);
            if (objCache == null)
            {
                string _filepath = filePath + cacheKey + fileExt;
                if (File.Exists(_filepath))
                {
                    FileStream _file = File.OpenRead(_filepath);
                    if (_file.CanRead)
                    {
                        Debug.WriteLine("缓存反序列化获取数据:" + cacheKey);
                        object obj = CacheHelper.BinaryDeSerialize(_file);
                        CacheData _data = (CacheData)obj;
                        if (_data != null)
                        {
                            //判断是否过期
                            if (_data.FailureTime >= DateTime.Now)
                            {
                                //将数据添加到内存
                                CacheHelper.SetCacheToMemory(cacheKey, _data);
                                return _data.Value;
                            }
                            else
                            {
                                Debug.WriteLine("数据过期:" + cacheKey);
                                File.Delete(_filepath);
                                //数据过期
                                return null;
                            }
                        }
                        else { return null; }
                    }
                    else { return null; }
                }
                else { return null; }
            }
            else {
                CacheData _data = (CacheData)objCache.Value;
                return _data.Value;
            }
        }
        /// <summary>
        /// 内存缓存数
        /// </summary>
        /// <returns></returns>
        public static object GetCacheCount()
        {
            return System.Runtime.Caching.MemoryCache.Default.GetCount();
        }
        /// <summary>
        /// 文件缓存数
        /// </summary>
        /// <returns></returns>
        public static object GetFileCacheCount()
        {
            DirectoryInfo di = new DirectoryInfo(filePath);
            return di.GetFiles().Length;
        }

        /// <summary>
        /// 设置数据缓存
        /// </summary>
        public static bool SetCache(string cacheKey, object objObject, CacheItemPolicy policy)
        {
            //System.Web.Caching.Cache objCache = HttpRuntime.Cache;
            //objCache.Insert(cacheKey, objObject);
            string _filepath = filePath + cacheKey + fileExt;
            if (Directory.Exists(filePath)==false) {
                Directory.CreateDirectory(filePath);
            }
            //设置缓存数据的相关参数
            CacheData data = new CacheData() { Value = objObject, CreateTime = DateTime.Now, AbsoluteExpiration = policy.AbsoluteExpiration, Priority = policy.Priority };
            CacheItem objCache = new CacheItem(cacheKey, data);
            FileStream stream = null;
            if (File.Exists(_filepath) == false)
            {
                stream = new FileStream(_filepath, FileMode.CreateNew, FileAccess.Write, FileShare.Write);
            }
            else {
                stream = new FileStream(_filepath, FileMode.Create, FileAccess.Write, FileShare.Write);
            }
            Debug.WriteLine("缓存序列化设置数据:" + cacheKey);
            CacheHelper.BinarySerialize(stream, data);
            return System.Runtime.Caching.MemoryCache.Default.Add(objCache, policy);
        }
        public static bool SetCacheToMemory(string cacheKey, CacheData data)
        {
            CacheItemPolicy policy = new CacheItemPolicy();
            CacheItem objCache = new CacheItem(cacheKey, data);
            policy.AbsoluteExpiration = data.AbsoluteExpiration;
            policy.Priority = CacheItemPriority.NotRemovable;
            return System.Runtime.Caching.MemoryCache.Default.Add(objCache, policy);
        }

        public static bool SetCache(string cacheKey, object objObject, DateTimeOffset AbsoluteExpiration)
        {
            //System.Web.Caching.Cache objCache = HttpRuntime.Cache;
            //objCache.Insert(cacheKey, objObject);
            CacheItemPolicy _priority = new CacheItemPolicy();
            _priority.Priority = CacheItemPriority.NotRemovable;
            _priority.AbsoluteExpiration = AbsoluteExpiration;
            return SetCache(cacheKey, objObject, _priority);
        }

        public static bool SetCache(string cacheKey, object objObject, CacheItemPriority priority)
        {
            //System.Web.Caching.Cache objCache = HttpRuntime.Cache;
            //objCache.Insert(cacheKey, objObject);
            CacheItemPolicy _priority = new CacheItemPolicy();
            _priority.Priority = priority;
            _priority.AbsoluteExpiration = System.Runtime.Caching.ObjectCache.InfiniteAbsoluteExpiration;
            return SetCache(cacheKey, objObject, _priority);
        }
        /// <summary>
        /// 设置数据缓存
        /// </summary>
        public static bool SetCache(string cacheKey, object objObject)
        {
            //System.Web.Caching.Cache objCache = HttpRuntime.Cache;
            //objCache.Insert(cacheKey, objObject, null, DateTime.MaxValue, timeout, System.Web.Caching.CacheItemPriority.NotRemovable, null);
            return CacheHelper.SetCache(cacheKey, objObject, System.Runtime.Caching.CacheItemPriority.NotRemovable);
        }

        /// <summary>
        /// 移除指定数据缓存
        /// </summary>
        public static void RemoveCache(string cacheKey)
        {
            //System.Web.Caching.Cache cache = HttpRuntime.Cache;
            //cache.Remove(cacheKey);
            System.Runtime.Caching.MemoryCache.Default.Remove(cacheKey);
            string _filepath = filePath + cacheKey + fileExt;
            File.Delete(_filepath);
        }

        /// <summary>
        /// 移除全部缓存
        /// </summary>
        public static void RemoveAllCache()
        {
            //System.Web.Caching.Cache cache = HttpRuntime.Cache;
            //IDictionaryEnumerator cacheEnum = cache.GetEnumerator();
            //while (cacheEnum.MoveNext())
            //{
            //    cache.Remove(cacheEnum.Key.ToString());
            //}
            MemoryCache _cache = System.Runtime.Caching.MemoryCache.Default;
            foreach (var _c in _cache.GetValues(null))
            {
                _cache.Remove(_c.Key);
            }
            DirectoryInfo di = new DirectoryInfo(filePath);
            di.Delete(true);
        }
        /// <summary>
        /// 清除指定缓存
        /// </summary>
        /// <param name="type">1:内存 2:文件</param>
        public static void RemoveAllCache(int type)
        {
            if (type == 1)
            {
                MemoryCache _cache = System.Runtime.Caching.MemoryCache.Default;
                foreach (var _c in _cache.GetValues(null))
                {
                    _cache.Remove(_c.Key);
                }
            }
            else if (type == 2)
            {
                DirectoryInfo di = new DirectoryInfo(filePath);
                di.Delete(true);
            }
        }

        #region 流序列化
        public static void BinarySerialize(Stream stream, object obj)
        {
            try
            {
                stream.Seek(0, SeekOrigin.Begin);
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(stream, obj);
            }
            catch (Exception e)
            {
                IOHelper.WriteDebug(e);
            }
            finally
            {
                //stream.Close();
                stream.Dispose();
            }
        }

        public static object BinaryDeSerialize(Stream stream)
        {
            object obj = null;
            stream.Seek(0, SeekOrigin.Begin);
            try
            {
                BinaryFormatter formatter = new BinaryFormatter();
                obj = formatter.Deserialize(stream);
            }
            catch (Exception e)
            {
                IOHelper.WriteDebug(e);
            }
            finally
            {
                //stream.Close();
                stream.Dispose();
            }
            return obj;
        }
        #endregion
    }
}
时间: 2024-10-27 12:22:14

缓存处理类(MemoryCache结合文件缓存)的相关文章

Memcache缓存居然不如直接File文件缓存?

使用本地的环境测试10万次和 100万次 缓存的读写,测试环境和结果如下. 环境 Win7 x64 AMD7750双核 内存8G Apache 2.4.9 PHP 5.5.12 ts vc11 memcache 2.2.7 代码 <?php function convert($size) { $unit = array('b', 'kb', 'mb', 'gb', 'tb', 'pb'); return @round($size / pow(1024, ($i = floor(log($size

php 缓存工具类 实现网页缓存

php程序在抵抗大流量访问的时候动态网站往往都是难以招架,所以要引入缓存机制,一般情况下有两种类型缓存 一.文件缓存 二.数据查询结果缓存,使用内存来实现高速缓存 本例主要使用文件缓存. 主要原理使用缓存函数来存储网页显示结果,如果在规定时间里再次调用则可以加载缓存文件. 工具类代码: // 文件缓存类 class Cache { /** * $dir : 缓存文件存放目录 * $lifetime : 缓存文件有效期,单位为秒 * $cacheid : 缓存文件路径,包含文件名 * $ext :

php 文件缓存

http://www.oschina.net/code/snippet_162279_6098 <?php class cache {       private static $_instance = null;     protected $_options = array(         'cache_dir'        => "./",         'file_name_prefix' => 'cache',         'mode'      

PHP缓存之文件缓存

1.PHP文件缓存内容保存格式        PHP文件缓存内容保存格式主要有三种: (1)变量 var_export 格式化成PHP正常的赋值书写格式: (2)变量 serialize 序列化之后保存,用的时候反序列化: (3)变量 json_encode格式化之后保存,用的时候json_decode 互联网上测试结果是:serialize格式的文件解析效率大于Json,Json的解析效率大于PHP正常赋值. 所以我们要是缓存数据建议采用序列化的形式解析数据会更快. 2.PHP文件缓存的简单案

分享基于MemoryCache(内存缓存)的缓存工具类,C# B/S 、C/S项目均可以使用!

using System; using System.Collections.Generic; using System.Linq; using System.Runtime.Caching; using System.Text; using System.Threading.Tasks; namespace AutoLogisticsPH.Common.Utils { /// <summary> /// 基于MemoryCache(内存缓存)的缓存工具类 /// Author:左文俊 ///

Volley随笔之文件缓存DiskBasedCache类

Volley提供了一个基于文件的缓存类DiskBasedCache保存缓存数据.这个类完成缓存工作的原理大致如此,首先声明一个文件夹,文件夹下的文件与cacheKey一一对应,也就是说每一个文件时不同网络请求的返回数据.文件的格式是这样,文件头是数据结构CacheHeader,描述了缓存的信息,之后就是缓存数据. 下面是DiskBasedCache的代码,不得不说很优美! /*  * Copyright (C) 2011 The Android Open Source Project * * L

PHP文件缓存类

1 <?php 2 /** 3 * @desc 文件缓存 4 */ 5 class Cache{ 6 const C_FILE = '/Runtime/'; 7 private $dir = ''; 8 const EXT = '.tpl'; 9 private $filename = ''; 10 public function __construct($dir = ''){ 11 $this->dir = $dir; 12 13 } 14 /** 15 * @desc 设置文件缓存 16

PHP高效文件缓存类FCache

自己用的阿里云低配置,最近访问不错,经常出现mysql崩溃的问题,提单说请加内存,这回复还不如直接说:请交钱! 于是自己在git找了php的文件缓存,发现都是将缓存放到一个缓存文件!!!意味着: 1.无论你是读取多大的数据,都需要从磁盘读出整个文件到内存,然后解析,获取你要的部分数据: 2.在缓存数据很大的时候,并不能起到缓存加速网站访问的目的,同时增加磁盘的读写负荷: 3.在某一个临界点,可能会导致缓存性能比数据库还差: 4.未经过严格测试,个人预估一般网站的数据都会达到100M以上,如果每次

【安卓笔记】硬盘缓存工具类的编写

DiskLruCache(https://github.com/JakeWharton/DiskLruCache)想必大家都很熟悉.(不熟悉的请看这里),它是jakewharton大神写的一个开源库,提供了硬盘缓存的方案. 但是该库的API比较简单,有时候并不能满足我们使用.比如说如果你想把缓存中的数据以Bitmap的形式返回,API并没有提供这样的方法,我们必须通过DiskLruCache#get方法返回来的Snapshot获得输入流,然后将流转化为Bitmap.另外,构建DiskLruCac