一、阿里云OCS简单介绍
阿里云OCS兼容Memcached，因为OCS就相当于Memcached的服务器端，我们代码只是当作客户端，链接上服务器端就行了。阿里云OCS介绍详情见 http://www.aliyun.com/product/ocs?spm=5176.2020520107.0.0.s2zgFk#Help 。
二、C#客户端链接OCS
1.阿里云文档上介绍的是用Enyim.Caching去链接OCS。那我们项目中就用nuget去下载Enyim.Caching包。nuget搜索Enyim，搜索到的结果如下图，第一个是nolog版本的，第二个是带log的，随便一个都可以。
nuget搜索结果如下：
2.安装成功以后，再链接OCS，写个初始化memcached的代码，代码如下。
using Enyim.Caching;
using Enyim.Caching.Configuration;
using Enyim.Caching.Memcached;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks; namespace OCS
{
public class MemCached
{
private static MemcachedClient MemClient; static readonly object padlock = new object();
//线程安全的单例模式
public static MemcachedClient getInstance(string hostName,string userName,string password)
{
if (MemClient == null)
{
lock (padlock)
{
if (MemClient == null)
{
MemClientInit(hostName,userName,password);
}
}
}
return MemClient;
} static void MemClientInit(string hostName,string userName,string password)
{
try
{
//初始化缓存
MemcachedClientConfiguration memConfig = new MemcachedClientConfiguration();
IPAddress newaddress = IPAddress.Parse(Dns.GetHostEntry(hostName).AddressList[].ToString());
IPEndPoint ipEndPoint = new IPEndPoint(newaddress, ); // 配置文件 - ip
memConfig.Servers.Add(ipEndPoint);
// 配置文件 - 协议
memConfig.Protocol = MemcachedProtocol.Binary;
// 配置文件-权限
memConfig.Authentication.Type = typeof(PlainTextAuthenticator);
memConfig.Authentication.Parameters["zone"] = "";
memConfig.Authentication.Parameters["userName"] = userName;
memConfig.Authentication.Parameters["password"] = password;
//下面请根据实例的最大连接数进行设置
memConfig.SocketPool.MinPoolSize = ;
memConfig.SocketPool.MaxPoolSize = ;
MemClient = new MemcachedClient(memConfig);
}
catch (Exception)
{
MemClient = null;
}
}
}
}
3.再写个服务去调用上面的初始化代码，创建MemcachedClient的实例去调用客户端代码。下面代码中的构造函数中的_setting.HostAddress, _setting.AccessId, _setting.AccessKey分别对应的是，OCS的链接地址，链接密码和OCS的实例ID。
using Enyim.Caching;
using Enyim.Caching.Memcached;
using Enyim.Caching.Memcached.Results;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Web.Script.Serialization;
using Zupo.Core.Caching;
using ServiceStack.Text;
using Newtonsoft.Json; namespace OCS
{
public class OCSService
{
IOCSSetting _setting; private MemcachedClient client; public OCSService(IOCSSetting setting)
{
this._setting = setting;
this.client = MemCached.getInstance(_setting.HostAddress, _setting.AccessId, _setting.AccessKey);
} /// <summary>
/// 是否链接上服务器
/// </summary>
protected bool LinkServer
{
get
{
return client == null ? false : true;
}
} protected IGetOperationResult ExecuteGet(string key)
{
return client.ExecuteGet(key);
} /// <summary>
/// 根据key获得缓存
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
protected object Get(string key)
{
return client.Get(key);
} /// <summary>
/// 根据key获得缓存 泛型方法
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
protected T Get<T>(string key)
{
try
{
//JavaScriptSerializer jsonSerializer = new JavaScriptSerializer();
//string objectStr = client.Get(key).ToString();
var obj = client.Get(key);
if (obj != null)
{
return JsonConvert.DeserializeObject<T>(obj.ToString());
}
return default(T);
//return objectStr.FromJson<T>();
}
catch (Exception)
{
this.Remove(key);
return default(T);
}
} /// <summary>
/// 根据key获得缓存 泛型方法
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
protected List<T> GetList<T>(string key)
{
var objectStr = client.Get(key).ToString(); //return objectStr.FromJson<List<T>>();
return JsonConvert.DeserializeObject<List<T>>(objectStr);
} /// <summary>
/// 根据数组key获得数据 IDictionary
/// </summary>
/// <param name="keys"></param>
/// <returns></returns>
protected IDictionary<string, object> GetByKeys(string[] keys)
{
return client.Get(keys);
} /// <summary>
/// 该key值缓存是否存在
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public bool Contains(string key)
{
object value; return client.TryGet(key, out value);
} /// <summary>
/// 存储,有的话直接覆盖
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <returns></returns>
protected bool Set(string key, object value)
{
return client.Store(StoreMode.Set, key, value);
} /// <summary>
/// 存储,有的话直接覆盖
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <returns></returns>
protected bool Set<T>(string key, T value)
{
try
{
//执行序列化
//string objectStr = value.ToJson();
string objectStr = JsonConvert.SerializeObject(value, Formatting.Indented, new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore });
return client.Store(StoreMode.Set, key, objectStr);
}
catch(Exception)
{
return false;
} } /// <summary>
/// 存储,有的话直接覆盖
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <returns></returns>
protected bool Set<T>(string key, List<T> value)
{
//执行序列化
//string objectStr = value.ToJson();
string objectStr = JsonConvert.SerializeObject(value, Formatting.Indented, new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore });
return client.Store(StoreMode.Set, key, objectStr);
} /// <summary>
/// 存储,有的话直接覆盖
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="expire">失效时间：TimeSpan</param>
/// <returns></returns>
protected bool SetExpires(string key, object value, TimeSpan expire)
{
try
{
//string objectStr = value.ToJson();
string objectStr = JsonConvert.SerializeObject(value, Formatting.Indented, new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore });
return client.Store(StoreMode.Set, key, objectStr, expire);
}
catch(Exception)
{
return false;
} } /// <summary>
/// 存储,有的话直接覆盖
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="expire">失效时间：TimeSpan</param>
/// <returns></returns>
protected bool SetExpires<T>(string key, T value, TimeSpan expire)
{
//执行序列化
//string objectStr = value.ToJson();
string objectStr = JsonConvert.SerializeObject(value, Formatting.Indented, new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore });
return client.Store(StoreMode.Set, key, objectStr, expire);
} /// <summary>
/// 删除cached
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public void Remove(string key)
{
client.Remove(key);
} /// <summary>
/// Removes items by pattern
/// 该方法未实现
/// </summary>
/// <param name="pattern">pattern</param>
public virtual void RemoveByPattern(string pattern)
{
var regex = new Regex(pattern, RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.IgnoreCase);
//var keysToRemove = new List<String>(); //var allkeys = client.
//foreach (var key in allkeys)
// if (regex.IsMatch(key))
// keysToRemove.Add(key); //foreach (string key in keysToRemove)
//{
// Remove(key);
//}
} /// <summary>
/// 清空ocs缓存
/// </summary>
/// <returns></returns>
public void Clear()
{
client.FlushAll();
}
}
}
MemcachedClient
三、使用注意点
因为OCS只支持key/value的格式进行存储，所以我项目中先运用了Newtonsoft.Json去先对对象序列化，再存入到OCS上，读取的时候再反序列化读取。代码如下：
/// <summary>
/// 存储,有的话直接覆盖
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <returns></returns>
protected bool Set<T>(string key, T value)
{
try
{
//执行序列化
string objectStr = JsonConvert.SerializeObject(value, Formatting.Indented, new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore });
return client.Store(StoreMode.Set, key, objectStr);
}
catch(Exception)
{
return false;
} }
代码中设置了JsonSerializerSettings，因为项目用的是EF,一些对象里面的属性可能是另外一个对象还有是一些死循环的属性，所以数据量会比较大，直接执行序列化会内存溢出的，所以要在对象里面不需要序列化的属性上加上[JsonIgnore]，忽略此属性或字段序列化。
那么反序列化获取数据代码如下：
/// <summary>
/// 根据key获得缓存 泛型方法
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
protected T Get<T>(string key)
{
try
{
var obj = client.Get(key);
if (obj != null)
{
return JsonConvert.DeserializeObject<T>(obj.ToString());
}
return default(T);
}
catch (Exception)
{
this.Remove(key);
return default(T);
}
}