using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;
using System.Web; namespace Utils
{
/// <summary>
/// 自定义字典缓存帮助类
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
public class SynchronisedDictionary<TKey, TValue> : IDictionary<TKey, TValue>
{
private Dictionary<TKey, TValue> innerDict; // 缓存内容
private ReaderWriterLockSlim readWriteLock; // 读写锁 /// <summary>
/// 初始化构造函数
/// </summary>
/// <param name="dic"></param>
public SynchronisedDictionary(Dictionary<TKey, TValue> dic)
{
this.readWriteLock = new ReaderWriterLockSlim();
this.innerDict = dic ?? new Dictionary<TKey, TValue>();
} /// <summary>
/// 使用lambda初始化构造函数
/// </summary>
/// <param name="getKey"></param>
/// <param name="list"></param>
public SynchronisedDictionary(Func<TValue, TKey> getKey, List<TValue> list)
{
this.readWriteLock = new ReaderWriterLockSlim();
this.innerDict = new Dictionary<TKey, TValue>(); if (list != null && list.Count > )
{
foreach (var item in list)
{
var key = getKey(item);
if (this.innerDict.ContainsKey(key))
{
this.innerDict[key] = item;
}
else
{
this.innerDict.Add(getKey(item), item);
}
}
}
} /// <summary>
/// 同步缓存
/// </summary>
/// <param name="key">缓存键</param>
/// <param name="value">缓存值</param>
/// <param name="del">是否删除</param>
/// <remarks>
/// 新增:SyncCache(Id,Value,false)
/// 修改:SyncCache(Id,Value,false)
/// 删除:SyncCache(Id,null,true)
/// </remarks>
public void SyncCache(TKey key, TValue value, bool del = false)
{
if (del)
{
Remove(key);
}
else
{
this[key] = value;
}
} /// <summary>
/// 通过KeyValuePair新增缓存(建议使用SyncCache方法)
/// </summary>
/// <param name="item">KeyValuePair键值对</param>
public void Add(KeyValuePair<TKey, TValue> item)
{
using (new AcquireWriteLock(this.readWriteLock))
{
this.innerDict[item.Key] = item.Value;
}
} /// <summary>
/// 根据Key,Value新增缓存(建议使用SyncCache方法)
/// </summary>
/// <param name="key">缓存键</param>
/// <param name="value">缓存值</param>
public void Add(TKey key, TValue value)
{
using (new AcquireWriteLock(this.readWriteLock))
{
this.innerDict[key] = value;
}
} /// <summary>
/// 移除缓存(建议使用SyncCache方法)
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public bool Remove(TKey key)
{
bool isRemoved;
using (new AcquireWriteLock(this.readWriteLock))
{
isRemoved = this.innerDict.Remove(key);
}
return isRemoved;
} /// <summary>
/// 移除缓存(建议使用SyncCache方法)
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public bool Remove(KeyValuePair<TKey, TValue> item)
{
using (new AcquireWriteLock(this.readWriteLock))
{
return this.innerDict.Remove(item.Key);
}
} /// <summary>
/// 清空所有缓存
/// </summary>
public void Clear()
{
using (new AcquireWriteLock(this.readWriteLock))
{
this.innerDict.Clear();
}
} /// <summary>
/// 是否包含指定元素
/// </summary>
/// <param name="item">KeyValuePair键值对</param>
/// <returns></returns>
public bool Contains(KeyValuePair<TKey, TValue> item)
{
using (new AcquireReadLock(this.readWriteLock))
{
return this.innerDict.Contains<KeyValuePair<TKey, TValue>>(item);
}
} /// <summary>
/// 是否包含指定的键
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public bool ContainsKey(TKey key)
{
using (new AcquireReadLock(this.readWriteLock))
{
return this.innerDict.ContainsKey(key);
}
} /// <summary>
/// copy到指定Array中
/// </summary>
/// <param name="array"></param>
/// <param name="arrayIndex"></param>
public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
{
using (new AcquireReadLock(this.readWriteLock))
{
this.innerDict.ToArray<KeyValuePair<TKey, TValue>>().CopyTo(array, arrayIndex);
}
} /// <summary>
/// 获取枚举数
/// 可用foreach
/// </summary>
/// <returns></returns>
public IEnumerator GetEnumerator()
{
using (new AcquireReadLock(this.readWriteLock))
{
return this.innerDict.GetEnumerator();
}
} IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
{
using (new AcquireReadLock(this.readWriteLock))
{
return this.innerDict.GetEnumerator();
}
} /// <summary>
/// 获取缓存
/// </summary>
/// <param name="key">缓存键</param>
/// <param name="value">缓存值</param>
/// <returns></returns>
public bool TryGetValue(TKey key, out TValue value)
{
using (new AcquireReadLock(this.readWriteLock))
{
return this.innerDict.TryGetValue(key, out value);
}
} /// <summary>
/// 获取缓存的所有KEY
/// </summary>
public ICollection<TKey> Keys
{
get
{
using (new AcquireReadLock(this.readWriteLock))
{
return this.innerDict.Keys;
}
}
} /// <summary>
/// 获取缓存的所有VALUE
/// </summary>
public ICollection<TValue> Values
{
get
{
using (new AcquireReadLock(this.readWriteLock))
{
return this.innerDict.Values;
}
}
} /// <summary>
/// 获取缓存长度
/// </summary>
public int Count
{
get
{
using (new AcquireReadLock(this.readWriteLock))
{
return this.innerDict.Count;
}
}
} /// <summary>
/// TValue属性读写
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public TValue this[TKey key]
{
get
{
using (new AcquireReadLock(this.readWriteLock))
{
return this.innerDict[key];
}
}
set
{
using (new AcquireWriteLock(this.readWriteLock))
{
this.innerDict[key] = value;
}
}
} /// <summary>
/// 是否只读
/// </summary>
public bool IsReadOnly
{
get
{
return false;
}
}
} /// <summary>
/// 自定义列表缓存帮助类
/// </summary>
/// <typeparam name="TValue"></typeparam>
public class SynchronisedList<TValue> : IList<TValue>
{
private List<TValue> innerList; // 缓存内容
private ReaderWriterLockSlim readWriteLock; // 读写锁 /// <summary>
/// 初始化构造函数
/// </summary>
/// <param name="list"></param>
public SynchronisedList(IEnumerable<TValue> list)
{
innerList = new List<TValue>();
readWriteLock = new ReaderWriterLockSlim();
if (list != null && list.Count() > )
{
this.innerList.AddRange(list);
}
} /// <summary>
/// 获取缓存内容列表
/// </summary>
/// <returns></returns>
public List<TValue> GetList()
{
return this.innerList;
} /// <summary>
/// 获取索引
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public int IndexOf(TValue item)
{
using (new AcquireReadLock(this.readWriteLock))
{
return innerList.IndexOf(item);
}
} /// <summary>
/// 根据索引插入值
/// </summary>
/// <param name="index"></param>
/// <param name="item"></param>
public void Insert(int index, TValue item)
{
using (new AcquireWriteLock(this.readWriteLock))
{
innerList.Insert(index, item);
}
} /// <summary>
/// 根据索引移除值
/// </summary>
/// <param name="index"></param>
public void RemoveAt(int index)
{
using (new AcquireWriteLock(this.readWriteLock))
{
innerList.RemoveAt(index);
}
} /// <summary>
/// TValue属性读写
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public TValue this[int index]
{
get
{
using (new AcquireReadLock(this.readWriteLock))
{
return innerList[index];
}
}
set
{
using (new AcquireWriteLock(this.readWriteLock))
{
innerList[index] = value;
}
}
} /// <summary>
/// 插入值
/// </summary>
/// <param name="item"></param>
public void Add(TValue item)
{
using (new AcquireWriteLock(this.readWriteLock))
{
innerList.Add(item);
}
} /// <summary>
/// 清除缓存
/// </summary>
public void Clear()
{
using (new AcquireWriteLock(this.readWriteLock))
{
innerList.Clear();
}
} /// <summary>
/// 是否包含
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public bool Contains(TValue item)
{
using (new AcquireReadLock(this.readWriteLock))
{
return innerList.Contains(item);
}
} /// <summary>
/// copy到指定Array中
/// </summary>
/// <param name="array"></param>
/// <param name="arrayIndex"></param>
public void CopyTo(TValue[] array, int arrayIndex)
{
using (new AcquireReadLock(this.readWriteLock))
{
innerList.CopyTo(array, arrayIndex);
}
} /// <summary>
/// 获取缓存长度
/// </summary>
public int Count
{
get
{
using (new AcquireReadLock(this.readWriteLock))
{
return innerList.Count;
}
}
} /// <summary>
/// 只读属性
/// </summary>
public bool IsReadOnly
{
get
{
return false;
}
} /// <summary>
/// 移除值
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public bool Remove(TValue item)
{
using (new AcquireWriteLock(this.readWriteLock))
{
return innerList.Remove(item);
}
} /// <summary>
/// 获取枚举数
/// 可用foreach
/// </summary>
/// <returns></returns>
public IEnumerator<TValue> GetEnumerator()
{
using (new AcquireReadLock(this.readWriteLock))
{
return innerList.GetEnumerator();
}
} IEnumerator IEnumerable.GetEnumerator()
{
using (new AcquireReadLock(this.readWriteLock))
{
return innerList.GetEnumerator();
}
}
} class AcquireReadLock : IDisposable
{
private ReaderWriterLockSlim rwLock;
private bool disposedValue; public AcquireReadLock(ReaderWriterLockSlim rwLock)
{
this.rwLock = new ReaderWriterLockSlim();
this.disposedValue = false;
this.rwLock = rwLock;
this.rwLock.EnterReadLock();
} public void Dispose()
{
this.Dispose(true);
GC.SuppressFinalize(this);
} protected virtual void Dispose(bool disposing)
{
if (!this.disposedValue && disposing)
{
this.rwLock.ExitReadLock();
}
this.disposedValue = true;
}
} class AcquireWriteLock : IDisposable
{
private ReaderWriterLockSlim rwLock;
private bool disposedValue; public AcquireWriteLock(ReaderWriterLockSlim rwLock)
{
this.rwLock = new ReaderWriterLockSlim();
this.disposedValue = false;
this.rwLock = rwLock;
this.rwLock.EnterWriteLock();
} public void Dispose()
{
this.Dispose(true);
GC.SuppressFinalize(this);
} protected virtual void Dispose(bool disposing)
{
if (!this.disposedValue && disposing)
{
this.rwLock.ExitWriteLock();
}
this.disposedValue = true;
}
} public class WebCacheHelper
{
System.Web.Caching.Cache Cache = HttpRuntime.Cache; public void Set(string key, object data)
{
Cache.Insert(key, data);
}
public void Set(string key, object data, DateTime absoluteExpiration, TimeSpan slidingExpiration)
{
Cache.Insert(key, data, null, absoluteExpiration, slidingExpiration);
} public object Get(string Key)
{
return Cache[Key];
} public T Get<T>(string key)
{
return (T)Cache[key];
} public bool IsSet(string key)
{
return Cache[key] != null;
} public void Remove(string Key)
{
if (Cache[Key] != null)
{
Cache.Remove(Key);
}
} public void RemoveByPattern(string pattern)
{
IDictionaryEnumerator enumerator = Cache.GetEnumerator();
Regex rgx = new Regex(pattern, (RegexOptions.Singleline | (RegexOptions.Compiled | RegexOptions.IgnoreCase)));
while (enumerator.MoveNext())
{
if (rgx.IsMatch(enumerator.Key.ToString()))
{
Cache.Remove(enumerator.Key.ToString());
}
}
} public void Clear()
{
IDictionaryEnumerator enumerator = Cache.GetEnumerator();
while (enumerator.MoveNext())
{
Cache.Remove(enumerator.Key.ToString());
}
} }
}

C# CacheHelper的更多相关文章

  1. 缓存工具类CacheHelper

    代码: using System; using System.Collections.Generic; using System.Linq; using System.Text; using Syst ...

  2. MySqlHelper、CacheHelper

    MySqlHelper代码: using System; using System.Collections; using System.Collections.Generic; using Syste ...

  3. [Cache] C#操作缓存--CacheHelper缓存帮助类 [复制链接]

    using System;using System.Web;using System.Collections; namespace DotNet.Utilities{ public class Cac ...

  4. Asp.net Core CacheHelper 通用缓存帮助类

    using System; using Microsoft.Extensions.Caching.Memory; using System.Runtime; namespace UFX.Tools { ...

  5. [Cache] C#操作缓存--CacheHelper缓存帮助类 (转载)

    点击下载 CacheHelper.zip CacheHelper 缓存帮助类 C#怎么操作缓存 怎么设置和取缓存数据,都在这个类里面呢 下面看一下代码吧 /// <summary> /// ...

  6. CacheHelper工具类的使用

    package com.bbcmart.util; import net.sf.ehcache.Cache; import net.sf.ehcache.CacheManager; import ne ...

  7. C#操作缓存--CacheHelper缓存帮助类

    /// <summary>/// 类说明:Assistant/// 联系方式:361983679  /// 更新网站:<a href=\"http://www.cckan. ...

  8. C#缓存-依赖 CacheHelper

    缓存依赖文件或文件夹 //创建缓存依赖项 CacheDependency dep = new CacheDependency(fileName);//Server.MapPath("&quo ...

  9. C# WebHelper-CookieHelper,CacheHelper,SessionHelper

    常用web操作工具类,记录一下,本文记录的工具类,都要求引用 System.Web 1.CookieHelper /// <summary> /// Cookie工具类 /// </ ...

  10. WebHelper-SessionHelper、CookieHelper、CacheHelper、Tree

    ylbtech-Unitity: cs-WebHelper-SessionHelper.CookieHelper.CacheHelper.Tree SessionHelper.cs CookieHel ...

随机推荐

  1. sqlclr返回数据集案例

    ----------------------------------------------返回一张表,但只有一条数据,最后一次设置的. [Microsoft.SqlServer.Server.Sql ...

  2. Linux脚本学习随记

    把文件件的归属转移到其他用户上chown [-R] 账号名称:用户组名称 文件或目录 在进行hadoop分布式部署的时候,需要生成密钥对具体的操作如下先在master的hadoop目录下创建.sshm ...

  3. linux 之 snprintf函数用法

    int snprintf(char *restrict buf, size_t n, const char * restrict  format, ...); 函数说明:最多从源串中拷贝n-1个字符到 ...

  4. C/C++基础知识总结——C++简单程序设计

    1. sizeof 1.1 sizeof(类型名) 1.2 sizeof 表达式 1.3 返回所占字节大小 2. I/O流的输出格式 2.1 常用I/O流库操纵符 dec         十进制 he ...

  5. [转]Avoiding GDB Signal Noise.

    原文:http://peeterjoot.wordpress.com/2010/07/07/avoiding-gdb-signal-noise/ A quick note for future ref ...

  6. [转]Metasploit的meterpreter黑客脚本列表

    原文地址: 摘要: Metasploit的框架是一个令人难以置信的黑客攻击和渗透测试工具,每一个黑客称职的应该是熟悉和有能力的. 在上一篇文章中,我提供了你的 meterpreter 命令列表.这些命 ...

  7. 微软RDLC报表打印

    关于微软RDLC报表打印时文字拉伸问题(Windows server 2003 sp2) 最近我们开发的打印服务频频出现打印文字拉伸问题,客户意见络绎不绝,最为明显的是使用黑体加粗后 “2.0份” 打 ...

  8. 核心C#

    核心C# 内容提要: 声明变量:变量的初始化和作用域:C#的预定义数据类型:在C#程序中使用条件语句.循环和跳转语句指定执行流:枚举:名称空间: Main()方法:基本命令行C#编译器选项:使用Sys ...

  9. JS自动刷新页面一次

    <script type="text/javascript"> //刷新页面 if(location.href.indexOf("refresh=1" ...

  10. linux学习之linux的hostname修改详解《转》

    linux的hostname是一个kernel变量,可以通过hostname命令来查看本机的hostname.也可以直接cat /proc/sys/kernel/hostname查看. #hostna ...