C#链接阿里云OCS

一、阿里云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[0].ToString());
                IPEndPoint ipEndPoint = new IPEndPoint(newaddress, 11211);

                // 配置文件 - 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 = 5;
                memConfig.SocketPool.MaxPoolSize = 200;
                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();
        }
    }
}

三、使用注意点

　　因为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);
            }
        }