(已格式化)功能比较全的StackExchange.Redis封装帮助类(.Net/C#)

/// <summary>
/// Redis操作
/// </summary>
public class RedisHelper
{

    //static NewtonsoftSerializer serializer = new NewtonsoftSerializer();
    //static StackExchangeRedisCacheClient cacheClient = new StackExchangeRedisCacheClient(serializer);
    //private static IDatabase db = cacheClient.Database;

    private static string connstr = System.Configuration.ConfigurationManager.AppSettings["redisCacheClient"];// "127.0.0.1:6379,allowadmin=true";
    private static ConnectionMultiplexer conn = ConnectionMultiplexer.Connect(connstr);
    private static IDatabase db =  conn.GetDatabase(1);


    /// <summary>
    /// 获取系统的redis key前缀
    /// </summary>
    /// <param name="resourceid">资源Id</param>
    /// <returns></returns>
    public static string GetMyKey(string resourceid = "")
    {
       
        string Key = "report_";
        if (!string.IsNullOrWhiteSpace(resourceid))
        {
            Key = string.Format("report_res_{0}", resourceid);
        }
        return Key;
    }

    #region String 可以设置过期时间 同步

    /// <summary>
    /// 保存单个key value
    /// </summary>
    /// <param name="key">Redis Key</param>
    /// <param name="value">保存的值</param>
    /// <param name="expiry">过期时间</param>
    /// <returns></returns>
    public static bool SetStringKey(string key, string value, TimeSpan? expiry = default(TimeSpan?))
    {
       
        return db.StringSet(key, value, expiry);
    }

    /// <summary>
    /// 保存多个key value
    /// </summary>
    /// <param name="arr">key</param>
    /// <returns></returns>
    public static bool SetStringKey(KeyValuePair<RedisKey, RedisValue>[] arr)
    {
        return db.StringSet(arr);
    }

    /// <summary>
    /// 保存一个对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static bool SetStringKey<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
    {
        string json = JsonConvert.SerializeObject(obj);
        return db.StringSet(key, json, expiry);
    }

    /// <summary>
    /// 获取单个key的值
    /// </summary>
    /// <param name="key">Redis Key</param>
    /// <returns></returns>

    public static RedisValue GetStringKey(string key)
    {
        return db.StringGet(key);
    }


    /// <summary>
    /// 获取多个Key
    /// </summary>
    /// <param name="listKey">Redis Key集合</param>
    /// <returns></returns>
    public static RedisValue[] GetStringKey(List<RedisKey> listKey)
    {
        return db.StringGet(listKey.ToArray());
    }

    /// <summary>
    /// 获取一个key的对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <returns></returns>
    public static T GetStringKey<T>(string key)
    {
        return JsonConvert.DeserializeObject<T>(db.StringGet(key));
    }
    /// <summary>
    /// 为数字增长val
    /// </summary>
    /// <param name="key"></param>
    /// <param name="val">可以为负</param>
    /// <returns>增长后的值</returns>
    public double StringIncrement(string key, double val = 1)
    {
        return db.StringIncrement(key, val);
    }

    /// <summary>
    /// 为数字减少val
    /// </summary>
    /// <param name="key"></param>
    /// <param name="val">可以为负</param>
    /// <returns>减少后的值</returns>
    public double StringDecrement(string key, double val = 1)
    {
        return db.StringDecrement(key, val);
    }

    #endregion

    #region String 可以设置过期时间 异步

    /// <summary>
    /// 保存单个key value
    /// </summary>
    /// <param name="key">Redis Key</param>
    /// <param name="value">保存的值</param>
    /// <param name="expiry">过期时间</param>
    /// <returns></returns>
    public static async Task<bool> SetStringKeyAsync(string key, string value, TimeSpan? expiry = default(TimeSpan?))
    {

        return await db.StringSetAsync(key, value, expiry);
    }

    /// <summary>
    /// 保存多个key value
    /// </summary>
    /// <param name="arr">key</param>
    /// <returns></returns>
    public static async Task<bool> SetStringKeyAsync(KeyValuePair<RedisKey, RedisValue>[] arr)
    {
        return await db.StringSetAsync(arr);
    }

    /// <summary>
    /// 保存一个对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static async Task<bool> SetStringKeyAsync<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
    {
        string json = JsonConvert.SerializeObject(obj);
        return await db.StringSetAsync(key, json, expiry);
    }

    /// <summary>
    /// 获取单个key的值
    /// </summary>
    /// <param name="key">Redis Key</param>
    /// <returns></returns>

    public static async Task<RedisValue>  GetStringKeyAsync(string key)
    {
        return await db.StringGetAsync(key);
    }


    /// <summary>
    /// 获取多个Key
    /// </summary>
    /// <param name="listKey">Redis Key集合</param>
    /// <returns></returns>
    public static async Task<RedisValue[]> GetStringKeyAsync(List<RedisKey> listKey)
    {
        return await db.StringGetAsync(listKey.ToArray());
    }

    /// <summary>
    /// 获取一个key的对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <returns></returns>
    public static async Task<T> GetStringKeyAsync<T>(string key)
    {
        return JsonConvert.DeserializeObject<T>(await db.StringGetAsync(key));
    }
    /// <summary>
    /// 为数字增长val
    /// </summary>
    /// <param name="key"></param>
    /// <param name="val">可以为负</param>
    /// <returns>增长后的值</returns>
    public async Task<double> StringIncrementAsync(string key, double val = 1)
    {
        return await db.StringIncrementAsync(key, val);
    }

    /// <summary>
    /// 为数字减少val
    /// </summary>
    /// <param name="key"></param>
    /// <param name="val">可以为负</param>
    /// <returns>减少后的值</returns>
    public async Task<double> StringDecrementAsync(string key, double val = 1)
    {
        return await db.StringDecrementAsync(key, val);
    }
    #endregion

    #region Hash 同步
    /// <summary>
    /// 存储数据到hash表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="dataKey"></param>
    /// <param name="t"></param>
    /// <returns></returns>
    public static bool HashSet1<T>(string key, string dataKey, List<T> t)
    {
        string json = "";
        foreach (var item in t)
        {
            json = JsonConvert.SerializeObject(item);
            //listHashEntry.Add(new HashEntry(getModelId(item), json));
        }
        return db.HashSet(key, dataKey, json);

        //return await  ({
        //    string json = ConvertJson(t);
        //    return db.HashSetAsync(key, dataKey, json);
        //});
    }
    /// <summary>
    /// 保存一个集合
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key">Redis Key</param>
    /// <param name="list">数据集合</param>
    /// <param name="getModelId"></param>
    public static void HashSet<T>(string key, List<T> list, Func<T, string> getModelId)
    {
        List<HashEntry> listHashEntry = new List<HashEntry>();
        foreach (var item in list)
        {
            string json = JsonConvert.SerializeObject(item);
            listHashEntry.Add(new HashEntry(getModelId(item), json));
        }
        db.HashSet(key, listHashEntry.ToArray());
    }

    /// <summary>
    /// 获取Hash中的单个key的值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key">Redis Key</param>
    /// <param name="hasFildValue">RedisValue</param>
    /// <returns></returns>
    public static T GetHashKey<T>(string key, string hasFildValue)
    {
        if (!string.IsNullOrWhiteSpace(key) && !string.IsNullOrWhiteSpace(hasFildValue))
        {
            RedisValue value = db.HashGet(key, hasFildValue);
            if (!value.IsNullOrEmpty)
            {
                return JsonConvert.DeserializeObject<T>(value);
            }
        }
        return default(T);
    }

    /// <summary>
    /// 获取hash中的多个key的值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key">Redis Key</param>
    /// <param name="listhashFields">RedisValue value</param>
    /// <returns></returns>
    public static List<T> GetHashKey<T>(string key, List<RedisValue> listhashFields)
    {
        List<T> result = new List<T>();
        if (!string.IsNullOrWhiteSpace(key) && listhashFields.Count > 0)
        {
            RedisValue[] value = db.HashGet(key, listhashFields.ToArray());
            foreach (var item in value)
            {
                if (!item.IsNullOrEmpty)
                {
                    result.Add(JsonConvert.DeserializeObject<T>(item));
                }
            }
        }
        return result;
    }

    /// <summary>
    /// 获取hashkey所有Redis key
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <returns></returns>
    public static List<T> GetHashAll<T>(string key)
    {
        List<T> result = new List<T>();
        RedisValue[] arr = db.HashKeys(key);
        foreach (var item in arr)
        {
            if (!item.IsNullOrEmpty)
            {
                result.Add(JsonConvert.DeserializeObject<T>(item));
            }
        }
        return result;
    }

    /// <summary>
    /// 获取hashkey所有的值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <returns></returns>
    public static List<T> HashGetAll<T>(string key)
    {
        List<T> result = new List<T>();
        HashEntry[] arr = db.HashGetAll(key);
        foreach (var item in arr)
        {
            if (!item.Value.IsNullOrEmpty)
            {
                result.Add(JsonConvert.DeserializeObject<T>(item.Value));
            }
        }
        return result;
    }

    /// <summary>
    /// 删除hasekey
    /// </summary>
    /// <param name="key"></param>
    /// <param name="hashField"></param>
    /// <returns></returns>
    public static bool DeleteHase(RedisKey key, RedisValue hashField)
    {
        return db.HashDelete(key, hashField);
    }

    #endregion

    #region Hash 异步
    /// <summary>
    /// 存储数据到hash表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="dataKey"></param>
    /// <param name="t"></param>
    /// <returns></returns>
    public static async Task<bool> HashSetAsync<T>(string key, string dataKey, List<T> t)
    {
        string json = "";
        foreach (var item in t)
        {
            json = JsonConvert.SerializeObject(item);
            //listHashEntry.Add(new HashEntry(getModelId(item), json));
        }
        return await db.HashSetAsync(key, dataKey, json);

        //return await  ({
        //    string json = ConvertJson(t);
        //    return db.HashSetAsync(key, dataKey, json);
        //});
    }

    ///// <summary>
    ///// 保存一个集合
    ///// </summary>
    ///// <typeparam name="T"></typeparam>
    ///// <param name="key">Redis Key</param>
    ///// <param name="list">数据集合</param>
    ///// <param name="getModelId"></param>
    //public static async Task<bool> HashSetAsync<T>(string key, List<T> list, Func<T, string> getModelId)
    //{
    //    List<HashEntry> listHashEntry = new List<HashEntry>();
    //    string json = "";
    //    foreach (var item in list)
    //    {
    //        json = JsonConvert.SerializeObject(item);
    //        listHashEntry.Add(new HashEntry(getModelId(item), json));
    //    }
    //   return await db.HashSetAsync(key, listHashEntry.ToArray());
    //}

    /// <summary>
    /// 获取Hash中的单个key的值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key">Redis Key</param>
    /// <param name="hasFildValue">RedisValue</param>
    /// <returns></returns>
    public static async Task<T> GetHashKeyAsync<T>(string key, string hasFildValue)
    {
        if (!string.IsNullOrWhiteSpace(key) && !string.IsNullOrWhiteSpace(hasFildValue))
        {
            RedisValue value = await db.HashGetAsync(key, hasFildValue);
            if (!value.IsNullOrEmpty)
            {
                return JsonConvert.DeserializeObject<T>(value);
            }
        }
        return default(T);
    }

    /// <summary>
    /// 获取hash中的多个key的值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key">Redis Key</param>
    /// <param name="listhashFields">RedisValue value</param>
    /// <returns></returns>
    public static async Task<List<T>> GetHashKeyAsync<T>(string key, List<RedisValue> listhashFields)
    {
        List<T> result = new List<T>();
        if (!string.IsNullOrWhiteSpace(key) && listhashFields.Count > 0)
        {
            RedisValue[] value = await db.HashGetAsync(key, listhashFields.ToArray());
            foreach (var item in value)
            {
                if (!item.IsNullOrEmpty)
                {
                    result.Add(JsonConvert.DeserializeObject<T>(item));
                }
            }
        }
        return result;
    }

    /// <summary>
    /// 获取hashkey所有Redis key
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <returns></returns>
    public static async Task<List<T>> GetHashAllAsync<T>(string key)
    {
        List<T> result = new List<T>();
        RedisValue[] arr =await db.HashKeysAsync(key);
        foreach (var item in arr)
        {
            if (!item.IsNullOrEmpty)
            {
                result.Add(JsonConvert.DeserializeObject<T>(item));
            }
        }
        return result;
    }

    /// <summary>
    /// 获取hashkey所有的值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <returns></returns>
    public static async Task<List<T>> HashGetAllAsync<T>(string key)
    {
        List<T> result = new List<T>();
        HashEntry[] arr =await db.HashGetAllAsync(key);
        foreach (var item in arr)
        {
            if (!item.Value.IsNullOrEmpty)
            {
                result.Add(JsonConvert.DeserializeObject<T>(item.Value));
            }
        }
        return result;
    }

    /// <summary>
    /// 删除hasekey
    /// </summary>
    /// <param name="key"></param>
    /// <param name="hashField"></param>
    /// <returns></returns>
    public static async Task<bool> DeleteHaseAsync(RedisKey key, RedisValue hashField)
    {
        return await db.HashDeleteAsync(key, hashField);
    }

    #endregion

    #region key 同步

    /// <summary>
    /// 删除单个key
    /// </summary>
    /// <param name="key">redis key</param>
    /// <returns>是否删除成功</returns>
    public static bool KeyDelete(string key)
    {
        return db.KeyDelete(key);
    }

    /// <summary>
    /// 删除多个key
    /// </summary>
    /// <param name="keys">rediskey</param>
    /// <returns>成功删除的个数</returns>
    public static long keyDelete(RedisKey[] keys)
    {
        return db.KeyDelete(keys);
    }

    /// <summary>
    /// 判断key是否存储
    /// </summary>
    /// <param name="key">redis key</param>
    /// <returns></returns>
    public static bool KeyExists(string key)
    {
        return db.KeyExists(key);
    }

    /// <summary>
    /// 重新命名key
    /// </summary>
    /// <param name="key">就的redis key</param>
    /// <param name="newKey">新的redis key</param>
    /// <returns></returns>
    public static bool KeyRename(string key, string newKey)
    {
        return db.KeyRename(key, newKey);
    }

    /// <summary>
    /// 设置Key的时间
    /// </summary>
    /// <param name="key">redis key</param>
    /// <param name="expiry"></param>
    /// <returns></returns>
    public static bool KeyExpire(string key, TimeSpan? expiry = default(TimeSpan?))
    {
        return db.KeyExpire(key, expiry);
    }
    #endregion

    #region key 异步

    /// <summary>
    /// 删除单个key
    /// </summary>
    /// <param name="key">redis key</param>
    /// <returns>是否删除成功</returns>
    public static async Task<bool> KeyDeleteAsync(string key)
    {
        return await db.KeyDeleteAsync(key);
    }

    /// <summary>
    /// 删除多个key
    /// </summary>
    /// <param name="keys">rediskey</param>
    /// <returns>成功删除的个数</returns>
    public static async Task<long> keyDeleteAsync(RedisKey[] keys)
    {
        return await db.KeyDeleteAsync(keys);
    }

    /// <summary>
    /// 判断key是否存储
    /// </summary>
    /// <param name="key">redis key</param>
    /// <returns></returns>
    public static async Task<bool> KeyExistsAsync(string key)
    {
        return await db.KeyExistsAsync(key);
    }

    /// <summary>
    /// 重新命名key
    /// </summary>
    /// <param name="key">就的redis key</param>
    /// <param name="newKey">新的redis key</param>
    /// <returns></returns>
    public static async Task<bool> KeyRenameAsync(string key, string newKey)
    {
        return await db.KeyRenameAsync(key, newKey);
    }


    /// <summary>
    /// 设置Key的时间
    /// </summary>
    /// <param name="key">redis key</param>
    /// <param name="expiry"></param>
    /// <returns></returns>
    public static async Task<bool> KeyExpireAsync(string key, TimeSpan? expiry = default(TimeSpan?))
    {
        return await db.KeyExpireAsync(key, expiry);
    }
    #endregion


    #region List 同步

    /// <summary>
    /// 移除指定ListId的内部List的值
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public void ListRemove<T>(string key, T value)
    {
         db.ListRemove(key, JsonConvert.SerializeObject(value));
    }

    /// <summary>
    /// 获取指定key的List
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public List<T> ListRange<T>(string key)
    {
        var values = db.ListRange(key);
        List<T> result = new List<T>();
        foreach (var item in values)
        {
            var model = JsonConvert.DeserializeObject<T>(item);
            result.Add(model);
        }
        return result;
    }

    /// <summary>
    /// 入队
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public void ListRightPush<T>(string key, T value)
    {
        db.ListRightPush(key, JsonConvert.SerializeObject(value));
    }

    /// <summary>
    /// 出队
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <returns></returns>
    public T ListRightPop<T>(string key)
    {
        var value = db.ListRightPop(key);
        return JsonConvert.DeserializeObject<T>(value);
    }

    /// <summary>
    /// 获取集合中的数量
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public long ListLength(string key)
    {
        return db.ListLength(key);
    }

    #endregion 同步方法

    #region List 异步

    /// <summary>
    /// 移除指定ListId的内部List的值
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public async Task<long> ListRemoveAsync<T>(string key, T value)
    {
        return await db.ListRemoveAsync(key, JsonConvert.SerializeObject(value));
    }

    /// <summary>
    /// 获取指定key的List
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public async Task<List<T>> ListRangeAsync<T>(string key)
    {
        var values =await db.ListRangeAsync(key);
        List<T> result = new List<T>();
        foreach (var item in values)
        {
            var model = JsonConvert.DeserializeObject<T>(item);
            result.Add(model);
        }
        return result;
    }

    /// <summary>
    /// 入队
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public async Task<long> ListRightPushAsync<T>(string key, T value)
    {
        return await db.ListRightPushAsync(key, JsonConvert.SerializeObject(value));
    }

    /// <summary>
    /// 出队
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <returns></returns>
    public async Task<T> ListRightPopAsync<T>(string key)
    {
        var value = await db.ListRightPopAsync(key);
        return JsonConvert.DeserializeObject<T>(value);
    }

   
    /// <summary>
    /// 获取集合中的数量
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public async Task<long> ListLengthAsync(string key)
    {
        return await db.ListLengthAsync(key);
    }

    #endregion 异步方法
    

    #region SortedSet 同步

    /// <summary>
    /// 添加
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <param name="score"></param>
    public static bool SortedSetAdd<T>(string key, T value, double score)
    {
        return db.SortedSetAdd(key, JsonConvert.SerializeObject(value), score);
    }

    /// <summary>
    /// 删除
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public static bool SortedSetRemove<T>(string key, T value)
    {
        return db.SortedSetRemove(key, JsonConvert.SerializeObject(value));
    }

    /// <summary>
    /// 获取全部
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static List<T> SortedSetRangeByRank<T>(string key)
    {
            var values = db.SortedSetRangeByRank(key);

        List<T> result = new List<T>();
        foreach (var item in values)
        {
            var model = JsonConvert.DeserializeObject<T>(item);
            result.Add(model);
        }
        return result;
    }

    /// <summary>
    /// 获取集合中的数量
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static long SortedSetLength(string key)
    {
        return db.SortedSetLength(key);
    }

    #endregion 同步方法

    #region SortedSet 异步

    /// <summary>
    /// 添加
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <param name="score"></param>
    public static async Task<bool> SortedSetAddAsync<T>(string key, T value, double score)
    {
        return await db.SortedSetAddAsync(key, JsonConvert.SerializeObject(value), score);
    }

    /// <summary>
    /// 删除
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public static async Task<bool> SortedSetRemoveAsync<T>(string key, T value)
    {
        return await db.SortedSetRemoveAsync(key, JsonConvert.SerializeObject(value));
    }

    /// <summary>
    /// 获取全部
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static async Task<List<T>> SortedSetRangeByRankAsync<T>(string key)
    {
        var values = await db.SortedSetRangeByRankAsync(key);
        List<T> result = new List<T>();
        foreach (var item in values)
        {
            var model = JsonConvert.DeserializeObject<T>(item);
            result.Add(model);
        }
        return result;
    }

    /// <summary>
    /// 获取集合中的数量
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static async Task<long> SortedSetLengthAsync(string key)
    {
        return await db.SortedSetLengthAsync(key);
    }

    #endregion 异步方法
    

    /// <summary>
    /// 追加值
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public static void StringAppend(string key, string value)
    {
        ////追加值，返回追加后长度
        long appendlong = db.StringAppend(key, value);
    }

}

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 194,761评论 5赞 460
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 81,953评论 2赞 371
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 141,998评论 0赞 320
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 52,248评论 1赞 263
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 61,130评论 4赞 356
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 46,145评论 1赞 272
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 36,550评论 3赞 381
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 35,236评论 0赞 253
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 39,510评论 1赞 291
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 34,601评论 2赞 310
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 36,376评论 1赞 326
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,247评论 3赞 313
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 37,613评论 3赞 299
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 28,911评论 0赞 17
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,191评论 1赞 250
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 41,532评论 2赞 342
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 40,739评论 2赞 335

(已格式化)功能比较全的StackExchange.Redis封装帮助类(.Net/C#)

推荐阅读更多精彩内容