第一次正式小用Redis存储

由于要做一个同一个页面上多种图表数据的下载，考虑到Azure上面的session很不稳定（可用Redis provider存储session，较稳定），故决定改为Azure支持的Redis，顺便也学习一下这种新的存储方式。

关于Redis的介绍这里不赘述了，他可存储多种类型的数据，不过还是相当基本的那些数据类型。

开始的设计是，利用Redis的Hashs存储每一个数据表的行列信息。在写了一系列代码后，发现这样的话执行速度上会有很大的影响。

后来经同事提醒，可以将table转换为json再进行Redis的String类型的存储。

在Azure门户上进行相应的Redis的配置。

然后先建立一个RedisClient类

 public class RedisClient
    {        
        private static readonly ILogger _logger = LoggerFactory.GetLogger(LoggerSourceName);
        private const string LoggerSourceName = "RedisClient";

        private static readonly Lazy<ConnectionMultiplexer> LazyConnection = new Lazy<ConnectionMultiplexer>(() =>
        {
            _logger.Info(LoggerSourceName, "Begin to create Redis connection");

            //read connection information from storage/configuration-redis/Redis.config
            CloudStorageAccount storageAccount = CloudStorageAccount.Parse(Config.CloudStorageAccount);
            CloudBlobContainer container = storageAccount.CreateCloudBlobClient().GetContainerReference("configuration-redis");
            if (!container.Exists())
                throw new ConfigurationErrorsException("fail to get redis connection string");
            CloudBlockBlob blob = container.GetBlockBlobReference("Redis.config");
            if (!blob.Exists())
                throw new ConfigurationErrorsException("fail to get redis connection string");
            string redisConnectionString;
            using (var ms = new MemoryStream())
            {
                blob.DownloadToStream(ms);
                ms.Position = 0;
                using (var sr = new StreamReader(ms))
                {
                    redisConnectionString = sr.ReadToEnd();
                }
            }


            ConnectionMultiplexer redis = ConnectionMultiplexer.Connect(redisConnectionString);
            redis.ConfigurationChanged += redis_ConfigurationChanged;
            redis.ConfigurationChangedBroadcast += redis_ConfigurationChangedBroadcast;
            redis.ConnectionFailed += redis_ConnectionFailed;
            redis.ConnectionRestored += redis_ConnectionRestored;
            return redis;
        });


        private static IDatabase _db;

        public static ConnectionMultiplexer Connection
        {
            get { return LazyConnection.Value; }
        }

        public static IDatabase Db
        {
            get { return _db ?? (_db = Connection.GetDatabase()); }
        }


        private static void redis_ConnectionRestored(object sender, ConnectionFailedEventArgs e)
        {
            _logger.Info(LoggerSourceName, "Redis ConnectionRestored");
        }

        private static void redis_ConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {
            _logger.Info(LoggerSourceName, "Redis ConnectionFailed");
        }

        private static void redis_ConfigurationChangedBroadcast(object sender, EndPointEventArgs e)
        {
            _logger.Info(LoggerSourceName, "Redis ConfigurationChangedBroadcast");
        }

        private static void redis_ConfigurationChanged(object sender, EndPointEventArgs e)
        {
            _logger.Info(LoggerSourceName, "Redis ConfigurationChanged");
        }
    }

 然后就是简单的写入啦。

 public static void SetRedisTable(string key, DataTable dt)
        {
            if (dt != null && !string.IsNullOrEmpty(key))
            {
                string value = JsonHelper.ToJson(dt);
                RedisClient.Db.StringSetAsync(key, value);
            }      
        }

还有读取。

 public static DataTable GetRedisTable(string key)
        {
            DataTable dt = new DataTable();
            if (!string.IsNullOrEmpty(key))
            {
                string s = RedisClient.Db.StringGet(key).ToString();
                if (!string.IsNullOrEmpty(s))
                    dt = JsonHelper.JsonToDataTable(s);
            }
            return dt;
        }

以上很简单

另有一段代码还不知道干嘛用，先记录下来。

public static class StackExchangeExtesion
    {
        public static T Get<T>(this IDatabase cache, string key)
        {
            var cachedValue = cache.StringGet(key);
            if (String.IsNullOrEmpty(cachedValue))
                return default(T);
            return JsonConvert.DeserializeObject<T>(cachedValue);
        }

        public static object Get(this IDatabase cache, string key)
        {
            var cachedValue = cache.StringGet(key);
            if (String.IsNullOrEmpty(cachedValue))
                return null;
            return JsonConvert.DeserializeObject<object>(cachedValue);
        }

        public static void Set(this IDatabase cache, string key, object value, TimeSpan? expiry = null, When when = When.Always, CommandFlags flags = CommandFlags.None)
        {
            cache.StringSet(key, JsonConvert.SerializeObject(value), expiry, when, flags);
        }

        public static void ListPush(this IDatabase cache, string key, object value)
        {
            cache.ListRightPush(key, JsonConvert.SerializeObject(value));
        }

        public static RedisValue[] ListRange(this IDatabase cache, string key, long start, long stop)
        {
            if (start >= cache.ListLength(key))
                return new RedisValue[0];

            return cache.ListRange(key, start, stop);
        }
    }