MemCaCheExtend 缓存基础操作

/// <summary>
/// 在原来MemberHelper基础上修正了每次都初始化的问题，增加了对泛型的支持。改用静态构造函数来初始化 ZhangQC 2016.08.15
/// </summary>
public class MemcacheExtend
{
//日志
public static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

/// <summary>
/// 初始化
/// </summary>
static MemcacheExtend()
{
Initialize();
}

private static readonly string Nserver = ConfigurationManager.AppSettings["Nserver"];

/// <summary> 
/// 初始化池
/// </summary>
public static void Initialize()
{
try
{
//分布Memcachedf服务IP 端口 
string[] servers = { Nserver };

SockIOPool pool = SockIOPool.GetInstance();

pool.SetServers(servers);
pool.InitConnections = 3;
pool.MinConnections = 3;
pool.MaxConnections = 5;
pool.SocketConnectTimeout = 1000000;
pool.SocketTimeout = 3000000;
pool.MaintenanceSleep = 30;
pool.Failover = true;
pool.Nagle = false;
pool.Initialize();
}
catch (Exception ex)
{
Log.ErrorFormat("初始化Memcached失败:{0}", ex);
}
}

/// <summary>
/// 插入缓存
/// </summary>
/// <param name="key">关键字</param>
/// <param name="value">内容</param>
/// <returns>返回是否插入成功(true 成功 | false 失败)</returns>
public static bool InsertMemcached(string key, object value)
{
bool result = false;
try
{
//缓存
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;
if (!mc.KeyExists(key))
{
//key值不存在时，添加缓存记录
result = mc.Add(key, value,
DateTime.Now.AddDays(Convert.ToInt32(ConfigurationManager.AppSettings["CacheExpiry"])));
}
}
catch (Exception ex)
{
Log.ErrorFormat("插入缓存时出错：{0}", ex);
}
return result;
}

/// <summary>
/// 删除缓存中的记录
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static bool DeleteMemcached(string key)
{
bool result = false;
try
{
//缓存
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;
if (mc.KeyExists(key))
{
//存在key值，删除与此key值的信息
result = mc.Delete(key);
}
}
catch (Exception ex)
{
Log.ErrorFormat("删除缓存记录时失败：{0}", ex);
}
return result;
}

/// <summary>
/// 清空缓存
/// </summary>
public static void FlushMemcached()
{
try
{
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;
mc.FlushAll();
}
catch (Exception ex)
{
Log.ErrorFormat("情况缓存时出错：{0}", ex);
}
}
/// <summary>
/// 获取某个键值下的value
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static object GetMemcached(string key)
{
object value = null;
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;

if (mc.KeyExists(key))
{
//存在key值，获取与此key值对应的value
value = mc.Get(key);
}
return value;
}

/// <summary>
/// 根据键值获取对应的缓存数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static T GetMemcached<T>(string key)
{

T value = default(T);
try
{
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;

if (mc.KeyExists(key))
{
//存在key值，获取与此key值对应的value
value = (T)mc.Get(key);
}
else
{
value = default(T);
}
}
catch (Exception ex)
{
Log.ErrorFormat("根据键值获取对应的缓存数据时出错:{0}", ex);
}
return value;
}


/// <summary>
/// 获取多个键值下的value
/// </summary>
/// <param name="keys">多个Key值</param>
/// <returns></returns>
public static object[] GetMultipleMemcached(string[] keys)
{
object[] value = null;
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;
//获取多个键值下的
value = mc.GetMultipleArray(keys);
return value;
}

/// <summary>
/// 判断键值是否存在
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static bool KeyExists(string key)
{
bool result = false;
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;
if (mc.KeyExists(key))
{
result = true;
}
else
{
result = false;
}
return result;
}

/// <summary>
/// 替换缓存的数据
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <returns></returns>
public static bool Replace(string key, object value)
{
bool result = false;
//缓存
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;
if (mc.KeyExists(key))
{
//存在Key值，进行替换
result = mc.Replace(key, value);
}
else
{
//如果不存在进行插入
result=InsertMemcached(key, value);
}
return result;
}

/// <summary>
/// 根据键获取值
/// </summary>
/// <param name="elementsValue"></param>
/// <param name="key"></param>
/// <returns></returns>
public static object GetValue(Dictionary<string, object> elementsValue, string key)
{
//缓存值不为空
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var item in elementsValue)
{
//存在键值对，返回object
if (item.Key == key)
{
return item.Value;
}
}
return null;
}


/// <summary>
/// 将获取到的值添加到缓存中
/// </summary>
/// <param name="key">键值对Key</param>
/// <param name="value">键值对Value</param>
/// <param name="parentKey">缓存Key</param>
public static void AddValue(string key, object value, string parentKey)
{

//实例化键值对
var elements = new Dictionary<string, object> { { key, value } };
//将key和Value组合成键值对
//将键值对追加缓存中
InsertMemcached(parentKey, elements);
}


/// <summary>
/// 尝试获取缓存，如果获取不到，执行匿名委托操作
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cacheKey"></param>
/// <param name="func"></param>
/// <returns></returns>
public static T TryGetFromCache<T>(string cacheKey, Func<T> func) where T : class
{
T value = default(T);
try
{
value = GetMemcached<T>(cacheKey);
//value还是默认值，那么代表没有获取到缓存
if (value == null || value.Equals(default(T)))
{
value = func.Invoke();
Replace(cacheKey, value);
}
}
catch (Exception ex)
{
Log.ErrorFormat("尝试获取缓存出错：{0}", ex);
}
finally
{

}
return value;
}


/// <summary>
/// 尝试获取缓存，如果获取不到，执行匿名委托操作
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cacheKey"></param>
/// <param name="func"></param>
/// <returns></returns>
public static List<T> TryGetFromCache<T>(string cacheKey, Func<List<T>> func) where T : class
{
var value = default(List<T>);
try
{
value = GetMemcached<List<T>>(cacheKey);
//value还是默认值，那么代表没有获取到缓存
if (value == null || value.Equals(default(T)))
{
value = func.Invoke();
Replace(cacheKey, value);
}
}
catch (Exception ex)
{
Log.ErrorFormat("尝试获取缓存出错：{0}", ex);
}
return value;
}
}