c#中使用Redis

先简单的介绍下Redis

下面是摘录自维基百科:


Redis是一个开源、支持网络、基于内存、键值对存储数据库,使用ANSI C编写。从2013年5月开始,Redis的开发由Pivotal赞助。在这之前,其开发由VMware赞助。根据月度排行网站DB-Engines.com的数据显示,Redis是最流行的键值对存储数据库。 Redis的外围由一个键、值映射的字典构成。与其他非关系型数据库主要不同在于:Redis中值的类型不仅限于字符串,还支持如下抽象数据类型:

数据模型

  • 字符串列表
  • 无序不重复的字符串集合
  • 有序不重复的字符串集合
  • 键、值都为字符串的哈希表

值的类型决定了值本身支持的操作。Redis支持不同无序、有序的列表,无序、有序的集合间的交集、并集等高级服务器端原子操作。

持久化

Redis通常将全部的数据存储在内存中。2.4版本后可配置为使用虚拟内存,一部分数据集存储在硬盘上,但这个特性废弃了。

目前通过两种方式实现持久化:

  • 使用快照,一种半持久耐用模式。不时的将数据集以异步方式从内存以RDB格式写入硬盘。

  • 1.1版本开始使用更安全的AOF格式替代,一种只能追加的日志类型。将数据集修改操作记录起来。Redis能够在后台对只可追加的记录作修改来避免无限增长的日志。

同步

Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步,从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。从盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制,使得从数据库在任何地方同步树时,可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。

性能

当数据依赖不再需要,Redis这种基于内存的性质,与在执行一个事务时将每个变化都写入硬盘的数据库系统相比就显得执行效率非常高。写与读操作速度没有明显差别。


好了,废话这么多,下面贴出自己写的一个RediaHelper类,大家共同学习

using System;
using System.Reflection;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ServiceStack.Redis;
using ServiceStack.Model;

namespace RedisHelper
{

    public class RedisHelperMethods
    {
        private const string Host = "192.168.100.120";


        /// <summary>
        /// 构造函数 初始化Redis连接
        /// </summary>
        /// <returns></returns>
        public RedisHelperMethods()
        {
            try
            {
                var client = new RedisClient(Host);
            }
            catch (Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// 存储值为string类型
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static void SetKey(string key, string value)
        {
            using (var client = new RedisClient(Host))
            {
                if (client.ContainsKey(key))
                {
                    client.Del(key);
                }
                client.Add<string>(key, value);
            }
        }

        /// <summary>
        /// 通过key获得string类型
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string GetKey(string key)
        {
            using (var client = new RedisClient(Host))
            {
                if (client.ContainsKey(key))
                    return client.Get<string>(key);
                else
                    return null;
            }
        }



        /// <summary>
        /// store 泛型值 
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static void StroteEntity<T>(T value)
        {
            using (var client = new RedisClient(Host))
            {
                var entity = client.As<T>();
                entity.Store(value);
            }
        }

        /// <summary>
        /// store 泛型类型数组
        /// </summary>
        /// <param name="vals"></param>
        /// <returns></returns>
        public static void StoreEntity<T>(T[] vals)
        {
            using (var client = new RedisClient(Host))
            {
                var entity = client.As<T>();
                entity.StoreAll(vals);
            }
        }

        /// <summary>
        /// store泛型类型列表
        /// </summary>
        /// <param name="vals"></param>
        /// <returns></returns>
        public static void StoreEntity<T>(List<T> vals)
        {

            using (var client = new RedisClient(Host))
            {
                var entity = client.As<T>();
                entity.StoreAll(vals);
            }
        }

        /// <summary>
        /// 获得泛型类型T的所有值
        /// </summary>
        /// <returns></returns>
        public static List<T> GetEntitys<T>()
        {
            using (var client = new RedisClient(Host))
            {
                var entity = client.As<T>();
                return entity.GetAll().ToList();
            }
        }

        /// <summary>
        /// 搜索实体
        /// </summary>
        /// <param name=""></param>
        /// <param name="DoSearch"></param>
        /// <returns></returns>
        public static IEnumerable<T> SearchEntitys<T>(Func<T, bool> DoSearch)
        {
            using (var client = new RedisClient(Host))
            {
                var entity = client.As<T>();
                return entity.GetAll().Where(DoSearch);
            }

        }

        /// <summary>
        /// 通过Id搜索
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public static T SearchEneitys<T>(long id)
        {
            using (var client = new RedisClient(Host))
            {
                var entity = client.As<T>();
                return entity.GetById(id);
            }
        }

        /// <summary>
        /// 获得泛型类型的下一个序列
        /// </summary>
        /// <returns></returns>
        public static long GetNextSequence<T>()
        {
            using (var client = new RedisClient(Host))
            {
                var entity = client.As<T>();
                return entity.GetNextSequence();
            }
        }


        /// <summary>
        /// 根据id删除
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public static void DeleteEntity<T>(long id)
        {
            using (var client = new RedisClient(Host))
            {
                var search = client.As<T>();
                var entity = search.GetById(id);
                if (entity == null)
                {
                    return;
                }
                search.DeleteById(id);
            }
        }

        /// <summary>
        /// 根据key Set存储
        /// </summary>
        /// <param name="key"></param>
        /// <param name="val"></param>
        /// <returns></returns>
        public static void SetEntity<T>(string key, T val)
        {
            using (var client = new RedisClient(Host))
            {
                var entitys = client.As<T>();

                long id = (long)val.GetType().GetProperty("Id").GetValue(val, null);
                string entityname = typeof(T).Name.ToLower();
                key = string.Format("{0}:{1}:{2}", key, entityname, id);
                entitys.SetEntry(key, val);
            }
        }

        /// <summary>
        /// 通过Key,Id获得泛型值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public static T GetEntityById<T>(string key, long id)
        {
            using (var client = new RedisClient(Host))
            {
                var entitys = client.As<T>();
                string entityname = typeof(T).Name;
                key = string.Format("{0}:{1}:{2}", key, entityname, id);
                return entitys.GetValue(key);
            }
        }

        /// <summary>
        /// 通过key更新
        /// </summary>
        /// <param name="key"></param>
        /// <param name="val"></param>
        /// <returns></returns>
        public static void UpdateEntity<T>(string key, T val)
        {
            using (var client = new RedisClient(Host))
            {
                var entitys = client.As<T>();
                //获得id
                long id = (long)val.GetType().GetProperty("Id").GetValue(val, null);
                string entityname = typeof(T).Name;
                key = string.Format("{0}:{1}:{2}", key, entityname, id);

                entitys.SetEntry(key, val);
            }
        }
        /// <summary>
        /// 通过ket获得泛型类型的所有值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static List<T> GetEntitys<T>(string key)
        {
            using (var client = new RedisClient(Host))
            {
                string entityname = typeof(T).Name;
                key = string.Format("{0}:{1}:{2}", key, entityname, "*");
                var search = client.SearchKeys(key).ToList();
                List<T> entitys = client.GetValues<T>(search);
                return entitys;
            }
        }
        /// <summary>
        /// 分页
        /// </summary>
        /// <param name="key"></param>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <returns></returns>
        public static List<T> GetPagedList<T>(string key, int start, int end)
        {
            using (var client = new RedisClient(Host))
            {
                string entityname = typeof(T).Name;
                string ids = string.Format("{0}:{1}", "ids", entityname);
                var search = client.GetRangeFromSortedList(ids, start, end);


                for (int i = 0; i < search.Count; i++)
                {
                    string s = search[i];
                    search[i] = string.Format("{0}:{1}:{2}", key, entityname, s);
                }
                List<T> entitys = client.GetValues<T>(search);
                return entitys;

            }
        }
    }
}

最后,不要脸的贴上我的Git地址.
MvcRedis

这个项目是打算使用MVc,然后redis作为后台的.~等有时间慢慢完善把,就这样鸟~.

c#中使用Redis》上有4条评论

发表评论

电子邮件地址不会被公开。 必填项已用*标注