ef 仓储模式 Redis

最新推荐文章于 2020-11-24 09:04:01 发布
最新推荐文章于 2020-11-24 09:04:01 发布
阅读量277 收藏 1
点赞数
文章标签： 数据库 json
原文链接：http://www.cnblogs.com/hanjun0612/p/9779838.html
版权

接着写一下 上一章提到的  

BaseRepositoryRedis.cs


先说说题外话：由于公司希望用到缓存来提高访问速度。那么我理所当然的想到redis。

这个无可厚非。可是当时我们的项目已经开发的差不多的了。。。。

我懒，也不可能到bll或者 dal去增加缓存代码。

于是我就想到了，既然我们的dal可以继承自BaseRepository.cs 那么一样也可以继承BaseRepositoryRedis.cs

只需要coder自己来选择是否需要缓存，需要的继承BaseRepositoryRedis，否则继承BaseRepository就好了！！！


说了这么多，那么放代码，

先创建一个RedisManager类（随便封装一下）

public class RedisManager<T> : BaseClass
    {
        RedisClient client = new RedisClient(RedisPath);


        #region RedisHelper

        /// <summary>
        /// 获取
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public virtual T Get<T>(string key)
        {
            var q = client.Get<T>(key);
            return q;
        }

        /// <summary>
        /// 设置
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <param name="expired"></param>
        /// <returns></returns>
        public virtual bool Set<T>(string key,T t,bool expired=true)
        {
            bool q=false;
            if (expired)
            {
                q = client.Set(key, t,DateTime.Now.AddDays(ExpiredTime));
            }
            else
            {
                q = client.Set(key, t);
            }
            
            return q;
        }

        /// <summary>
        /// 清空缓存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        public virtual bool Remove(string key)
        {
            return client.Remove(key);
        }

        /// <summary>
        /// 清空所有缓存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        public virtual void FlushAll()
        {
            client.FlushAll();
        }

        /// <summary>
        /// 获取所有key
        /// </summary>
        public virtual List<string> GetAllKeys()
        {
            var q = client.GetAllKeys();
            return q;
        }

        /// <summary>
        /// 获取所有键值对
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        public virtual IDictionary<string, T> GetAll(List<string> keys)
        {
            IDictionary<string, T> dict = client.GetAll<T>(keys);
            return dict;
        }

        #endregion

    }

然后创建接口

IDAL

namespace IDAL
{
    public interface IBaseRepositoryRedis<T>
    {
        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="entity">数据实体</param>
        /// <returns>添加后的数据实体</returns>
        T Add(T entity, bool hasRedis = true);

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="entity">数据实体</param>
        /// <returns>添加后的数据实体</returns>
        bool AddOK(T entity, bool hasRedis = true);

        /// <summary>
        /// 查询记录数
        /// </summary>
        /// <param name="predicate">条件表达式</param>
        /// <returns>记录数</returns>
        int Count(Expression<Func<T, bool>> predicate, bool hasRedis = true);

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="entity">数据实体</param>
        /// <returns>是否成功</returns>
        T Update(T entity, bool hasRedis = true);

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="entity">数据实体</param>
        /// <returns>是否成功</returns>
        bool UpdateOK(T entity, bool hasRedis = true);

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="entity">数据实体</param>
        /// <returns>是否成功</returns>
        bool Delete(T entity, bool hasRedis = true);

        /// <summary>
        /// 是否存在
        /// </summary>
        /// <param name="anyLambda">查询表达式</param>
        /// <returns>布尔值</returns>
        bool Exist(Expression<Func<T, bool>> anyLambda, bool hasRedis = true);

        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="whereLambda">查询表达式</param>
        /// <returns>实体</returns>
        T Find(Expression<Func<T, bool>> whereLambda, bool hasRedis = true);

        /// <summary>
        /// 查找数据列表
        /// </summary>
        /// <typeparam name="S">排序</typeparam>
        /// <param name="whereLamdba">查询表达式</param>
        /// <returns></returns>
        List<T> FindList(Expression<Func<T, bool>> whereLamdba, bool hasRedis = true);

        /// <summary>
        /// 查找数据列表
        /// </summary>
        /// <typeparam name="S">排序</typeparam>
        /// <param name="whereLamdba">查询表达式</param>
        /// <param name="isAsc">是否升序</param>
        /// <param name="orderLamdba">排序表达式</param>
        /// <returns></returns>
        List<T> FindList<S>(Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba, bool hasRedis = true);

        /// <summary>
        /// 查找分页数据列表
        /// </summary>
        /// <typeparam name="S">排序</typeparam>
        /// <param name="pageIndex">当前页</param>
        /// <param name="pageSize">每页记录数</param>
        /// <param name="totalRecord">总记录数</param>
        /// <param name="whereLamdba">查询表达式</param>
        /// <param name="isAsc">是否升序</param>
        /// <param name="orderLamdba">排序表达式</param>
        /// <returns></returns>
        List<T> FindPageList<S>(int pageIndex, int pageSize, out int totalRecord, Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba, bool hasRedis = true);

        List<T> FindListBySQL<T>(string sql, params object[] parameters);
        int ExecuteBySQL(string sql, params object[] parameters);
    }
}


IBLL

namespace IBLL
{
    public interface IBaseRepositoryRedisBLL<T> where T : class
    {
        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="entity">数据实体</param>
        /// <returns>添加后的数据实体</returns>
        T Add(T entity, bool hasRedis = true);

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="entity">数据实体</param>
        /// <returns>添加后的数据实体</returns>
        bool AddOK(T entity, bool hasRedis = true);

        /// <summary>
        /// 查询记录数
        /// </summary>
        /// <param name="predicate">条件表达式</param>
        /// <returns>记录数</returns>
        int Count(Expression<Func<T, bool>> predicate, bool hasRedis = true);

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="entity">数据实体</param>
        /// <returns>是否成功</returns>
        T Update(T entity, bool hasRedis = true);

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="entity">数据实体</param>
        /// <returns>是否成功</returns>
        bool UpdateOK(T entity, bool hasRedis = true);

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="entity">数据实体</param>
        /// <returns>是否成功</returns>
        bool Delete(T entity, bool hasRedis = true);

        /// <summary>
        /// 是否存在
        /// </summary>
        /// <param name="anyLambda">查询表达式</param>
        /// <returns>布尔值</returns>
        bool Exist(Expression<Func<T, bool>> anyLambda, bool hasRedis = true);

        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="whereLambda">查询表达式</param>
        /// <returns>实体</returns>
        T Find(Expression<Func<T, bool>> whereLambda, bool hasRedis = true);

        /// <summary>
        /// 查找数据列表
        /// </summary>
        /// <typeparam name="S">排序</typeparam>
        /// <param name="whereLamdba">查询表达式</param>
        /// <returns></returns>
        List<T> FindList(Expression<Func<T, bool>> whereLamdba, bool hasRedis = true);

        /// <summary>
        /// 查找数据列表
        /// </summary>
        /// <typeparam name="S">排序</typeparam>
        /// <param name="whereLamdba">查询表达式</param>
        /// <param name="isAsc">是否升序</param>
        /// <param name="orderLamdba">排序表达式</param>
        /// <returns></returns>
        List<T> FindList<S>(Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba, bool hasRedis = true);

        /// <summary>
        /// 查找分页数据列表
        /// </summary>
        /// <typeparam name="S">排序</typeparam>
        /// <param name="pageIndex">当前页</param>
        /// <param name="pageSize">每页记录数</param>
        /// <param name="totalRecord">总记录数</param>
        /// <param name="whereLamdba">查询表达式</param>
        /// <param name="isAsc">是否升序</param>
        /// <param name="orderLamdba">排序表达式</param>
        /// <returns></returns>
        List<T> FindPageList<S>(int pageIndex, int pageSize, out int totalRecord, Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba, bool hasRedis = true);

        List<T> FindListBySQL<T>(string sql, params object[] parameters);
        int ExecuteBySQL(string sql, params object[] parameters);
    }
}


DAL

这里，我们创建 BaseRepositoryRedis

namespace DAL.Base
{
    public class BaseRepositoryRedis<T> : BaseClass, IBaseRepositoryRedis<T> where T : class
    {
        public ELDBEntity dbEF = DbContextFactory.GetCurrentContext();
        RedisBLL<T> redis = new RedisBLL<T>();

        public virtual T Add(T entity,bool hasRedis=true)
        {
            dbEF.Entry<T>(entity).State = EntityState.Added;
            dbEF.SaveChanges();
            if (hasRedis)
            {
                var q = SaveRedis();
            }
            return entity;
        }

        public virtual bool AddOK(T entity, bool hasRedis = true)
        {
            dbEF.Entry<T>(entity).State = EntityState.Added;
            int count = dbEF.SaveChanges();
            if (hasRedis)
            {
                var q = SaveRedis();
            }
            return count > 0;
        }

        public virtual int Count(Expression<Func<T, bool>> predicate, bool hasRedis = true)
        {
            List<T> q = new List<T>();

            if (hasRedis)
            {
                var s = redis.Get<string>(typeof(T).ToString());
                if (string.IsNullOrEmpty(s))
                {
                    q = SaveRedis();
                }
                else
                {
                    q = JsonConvert.DeserializeObject<List<T>>(s);
                }
                return q.Count(predicate.Compile());
            }
            return dbEF.Set<T>().AsNoTracking().Count(predicate);
        }

        public virtual T Update(T entity, bool hasRedis = true)
        {
            dbEF.Set<T>().Attach(entity);
            dbEF.Entry<T>(entity).State = EntityState.Modified;
            dbEF.SaveChanges();
            if (hasRedis)
            {
                var q = SaveRedis();
            }
            return entity;
        }

        public virtual bool UpdateOK(T entity, bool hasRedis = true)
        {
            dbEF.Set<T>().Attach(entity);
            dbEF.Entry<T>(entity).State = EntityState.Modified;
            int count = dbEF.SaveChanges();
            if (hasRedis)
            {
                var q = SaveRedis();
            }
            return count>0;
        }

        public virtual bool Delete(T entity, bool hasRedis = true)
        {
            dbEF.Set<T>().Attach(entity);
            dbEF.Entry<T>(entity).State = EntityState.Deleted;
            int count = dbEF.SaveChanges(); 
            if (hasRedis)
            {
                var q = SaveRedis();
            }
            return count > 0;
        }

        public virtual bool Exist(Expression<Func<T, bool>> anyLambda, bool hasRedis = true)
        {
            List<T> q = new List<T>();

            if (hasRedis)
            {
                var s = redis.Get<string>(typeof(T).ToString());
                if (string.IsNullOrEmpty(s))
                {
                    q = SaveRedis();
                }
                else
                {
                    q = JsonConvert.DeserializeObject<List<T>>(s);
                }
                return q.Exists(anyLambda.Compile().ToPredicate());
            }
            return dbEF.Set<T>().AsNoTracking().Any(anyLambda);
        }

        public virtual T Find(Expression<Func<T, bool>> whereLambda, bool hasRedis = true)
        {
            List<T> q = new List<T>();

            if (hasRedis)
            {
                var s = redis.Get<string>(typeof(T).ToString());
                if (string.IsNullOrEmpty(s))
                {
                    q = SaveRedis();
                }
                else
                {
                    q = JsonConvert.DeserializeObject<List<T>>(s);
                }

                return q.Find(whereLambda.Compile().ToPredicate());
            }
            T _entity = dbEF.Set<T>().AsNoTracking().FirstOrDefault<T>(whereLambda);
            return _entity;
        }

        public virtual List<T> FindList(Expression<Func<T, bool>> whereLamdba, bool hasRedis = true)
        {
            List<T> q = new List<T>();

            if (hasRedis)
            {
                var s = redis.Get<string>(typeof(T).ToString());
                if (string.IsNullOrEmpty(s))
                {
                    q = SaveRedis();
                }
                else
                {
                    q = JsonConvert.DeserializeObject<List<T>>(s);
                }
            }
            else
            {
                q = dbEF.Set<T>().AsNoTracking().Where<T>(whereLamdba).ToList();
            }
            return q.FindAll(whereLamdba.Compile().ToPredicate());;
        }

        public virtual List<T> FindList<S>(Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba, bool hasRedis = true)
        {
            List<T> q = new List<T>();

            if (hasRedis)
            {
                var s = redis.Get<string>(typeof(T).ToString());
                if (string.IsNullOrEmpty(s))
                {
                    q = SaveRedis();
                }
                else
                {
                    q = JsonConvert.DeserializeObject<List<T>>(s);
                }
                q = q.FindAll(whereLamdba.Compile().ToPredicate());
                
            }
            else
            { 
                q=dbEF.Set<T>().AsNoTracking().Where<T>(whereLamdba).ToList();
            }
            if (isAsc) q = q.OrderBy<T, S>(orderLamdba.Compile()).ToList();
            else q = q.OrderByDescending<T, S>(orderLamdba.Compile()).ToList();
            return q;
        }

        public virtual List<T> FindPageList<S>(int pageIndex, int pageSize, out int totalRecord, Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba, bool hasRedis = true)
        {
            List<T> q = new List<T>();

            if (hasRedis)
            {
                var s = redis.Get<string>(typeof(T).ToString());
                if (string.IsNullOrEmpty(s))
                {
                    q = SaveRedis();
                }
                else
                {
                    q = JsonConvert.DeserializeObject<List<T>>(s);
                }

                q = q.FindAll(whereLamdba.Compile().ToPredicate());
                
            }
            else
            {
                q = dbEF.Set<T>().AsNoTracking().Where<T>(whereLamdba).ToList();
            }
            totalRecord = q.Count();
            if (isAsc) q = q.OrderBy<T, S>(orderLamdba.Compile()).Skip<T>((pageIndex - 1) * pageSize).Take<T>(pageSize).ToList();
            else q = q.OrderByDescending<T, S>(orderLamdba.Compile()).Skip<T>((pageIndex - 1) * pageSize).Take<T>(pageSize).ToList();
            return q;
        }
        public virtual PagedList<T> FindPageList1<S>(int pageIndex, int pageSize, out int totalRecord, Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba, bool hasRedis = true)
        {
            List<T> q = new List<T>();
            if (hasRedis)
            {
                var s = redis.Get<string>(typeof(T).ToString());
                if (string.IsNullOrEmpty(s))
                {
                    q = SaveRedis();
                }
                else
                {
                    q = JsonConvert.DeserializeObject<List<T>>(s);
                }

                q = q.FindAll(whereLamdba.Compile().ToPredicate());
                
            }
            else
            {
                q = dbEF.Set<T>().AsNoTracking().Where<T>(whereLamdba).ToList();
            }
            totalRecord = q.Count();
            PagedList<T> resultList = null;
            if (isAsc) resultList = q.OrderBy<T, S>(orderLamdba.Compile()).ToPagedList(pageIndex, pageSize);
            else resultList = q.OrderByDescending<T, S>(orderLamdba.Compile()).ToPagedList(pageIndex, pageSize);
            return resultList;
        }


        public virtual List<T> FindListBySQL<T>(string sql, params object[] parameters)
        {
            var list = dbEF.Database.SqlQuery<T>(sql, parameters).ToList();
            return list;
        }

        public virtual int ExecuteBySQL(string sql, params object[] parameters)
        {
            var q = dbEF.Database.ExecuteSqlCommand(sql, parameters);
            return q;
        }

        private List<T> SaveRedis()
        {
            List<T> q = dbEF.Set<T>().AsNoTracking().ToList();
            var json = JsonConvert.SerializeObject(q);
            redis.Set<string>(typeof(T).Name, json);
            return q;
        }
    }
}


PS：说一下，为何要用json存储？ 其实我也很无奈（Redis抓狂 无法保存ef复杂对象），看链接：http://blog.csdn.net/hanjun0612/article/details/54409892


BLL

namespace BLL.Base
{
    public class BaseRepositoryRedisBLL<T> : BaseClass, IBaseRepositoryRedisBLL<T> where T : class
    {
        BaseRepositoryRedis<T> obj = new BaseRepositoryRedis<T>();
        public virtual T Add(T entity, bool hasRedis = true)
        {
            return obj.Add(entity);
        }

        public virtual bool AddOK(T entity, bool hasRedis = true)
        {
            return obj.AddOK(entity);
        }

        public virtual int Count(System.Linq.Expressions.Expression<Func<T, bool>> predicate, bool hasRedis = true)
        {
            return obj.Count(predicate);
        }

        public virtual T Update(T entity, bool hasRedis = true)
        {
            return obj.Update(entity);
        }

        public virtual bool UpdateOK(T entity, bool hasRedis = true)
        {
            return obj.UpdateOK(entity);
        }

        public virtual bool Delete(T entity, bool hasRedis = true)
        {
            return obj.Delete(entity);
        }

        public virtual bool Exist(System.Linq.Expressions.Expression<Func<T, bool>> anyLambda, bool hasRedis = true)
        {
            return obj.Exist(anyLambda);
        }

        public virtual T Find(Expression<Func<T, bool>> whereLambda, bool hasRedis = true)
        {
            return obj.Find(whereLambda);
        }

        public virtual List<T> FindList(Expression<Func<T, bool>> whereLamdba, bool hasRedis = true)
        {
            var _list = obj.FindList(whereLamdba);
            return _list;
        }

        public virtual List<T> FindList<S>(Expression<Func<T, bool>> whereLamdba, bool isAsc, System.Linq.Expressions.Expression<Func<T, S>> orderLamdba, bool hasRedis = true)
        {
            return obj.FindList<S>(whereLamdba, isAsc, orderLamdba);
        }

        public virtual List<T> FindPageList<S>(int pageIndex, int pageSize, out int totalRecord, Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba, bool hasRedis = true)
        {
            return obj.FindPageList<S>(pageIndex, pageSize, out totalRecord, whereLamdba, isAsc, orderLamdba);
        }

        public virtual PagedList<T> FindPageList1<S>(int pageIndex, int pageSize, out int totalRecord, Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba, bool hasRedis = true)
        {
            return obj.FindPageList1<S>(pageIndex, pageSize, out totalRecord, whereLamdba, isAsc, orderLamdba);
        }

        public virtual List<T> FindListBySQL<T>(string sql, params object[] parameters)
        {
            return obj.FindListBySQL<T>(sql, parameters);
        }

        public virtual int ExecuteBySQL(string sql, params object[] parameters)
        {
            return obj.ExecuteBySQL(sql, parameters);
        }
    }
}

最后，看一下用法

DAL 
 public class TestDAL : BaseRepositoryRedis<SYS_User>
    {
        //创建自定义方法
        public string HelloWorld(string name)
        {
            return name + " Hello";
        }

    }

BLL 
namespace BLL.Test
{
    //继承BaseRepositoryBLL，拥有常用方法
    public class TestBLL : BaseRepositoryRedisBLL<SYS_User>
    {
        
    }
}


转载于:https://www.cnblogs.com/hanjun0612/p/9779838.html

weixin_30535565
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
EFCache.RedisCache:实体框架缓存的 RedisCache 实现
06-15
EFCache.RedisCache 实体框架 6.1 ( ) ICache 接口的二级缓存的 RedisCache 实现。 纽吉特： 尚不支持缓存过期。 如何使用？ public class Configuration : DbConfiguration { public Configuration () { var redisCache = new RedisEFCache ( ConnectionMultiplexer . Connect ( RedisCacheConnectionString )); var transactionHandler = new CacheTransactionHandler ( redisCache ); AddInterceptor ( transactionHandler ); va
EF+Redis(StackExchange.Redis)实现分布式锁,自测可行
weixin_30539835的博客
07-15 724
电商平台 都会有抢购的情况，比如 1元抢购。 而抢购 最重要的 就是库存，很多情况下 库存处理不好，就会出现超卖现象。 本文将用redis为缓存，StackExchange 框架，消息队列方式 实现分布式锁的情况 一，效果 先看效果， 窗体下单 构建高并发情况 开多个控制台应用程序 处理订单 二，配置Redis <Redis.Service> ...
redis
ef_ef的博客
11-04 201
redis的介绍 先了解背景: 如今是web2.0时代(不懂的自己百度查), 所以数据的修改频率极其的高, 传统的关系型数据库对这种问题也束手无策, 因此NOSQL就出来了, 而redis就是一款高性能的NOSQL. 因为NOSQL数据的修改是在内存中而不是在硬盘上, 所以NOSQL相比于关系型数据库来说, 数据修改得更快, 性能更高, 但只适合储存少量数据, 不适合储存大量数据. 所以项目开发一般将NOSQL和关系型数据库结合使用, NOSQL存储易变的少量的数据, 而不易变的大型的数据交给关系型数据库解
.net Core 2.1 MVC+EF+Redis搭建
weixin_30667301的博客
08-03 841
官方学习资料 搭建空MVC框架 1.创建一个空模板 2.创建文件夹 Controllers、Models、Views 3.在Controllers文件夹下创建HomeController.cs 选择Controllers文件夹，右键-添加-新建项，选择MVC控制器类，添加HomeController.cs。 using System; using System.Colle...
redis指定配置文件启动_探索Redis设计与实现13：Redis集群机制及一个Redis架构演进实例...
weixin_39859819的博客
11-24 116
Replication(主从复制)Redis的replication机制允许slave从master那里通过网络传输拷贝到完整的数据备份，从而达到主从机制。为了实现主从复制，我们准备三个redis服务，依次命名为master，slave1，slave2。配置主服务器为了测试效果，我们先修改主服务器的配置文件redis.conf的端口信息1. port 6300配置从服务器replication相关...
Redis哨兵模式配置文件
03-26
Redis Sentinel，或者称为哨兵模式，是Redis集群架构中的一个重要组成部分，主要用于实现高可用性（HA）。在单机模式下，Redis服务器一旦宕机，将会导致服务不可用，哨兵模式就是为了克服这个问题而设计的。它监控...
redis集群模式配置文件
04-16
Redis搭建集群模式的配置文件，搭建的是3主3从的集群模式，其中提供了一个bat批处理的启动文件，将这些配置文件复制放入到【Redis安装目录】下面，然后双击【start_cluster.bat】文件，此时会弹出多个CMD弹出框，在...
redis主从模式与哨兵模式例子
07-27
redis主从模式与哨兵模式例子 # 当前Sentinel服务运行的端口 port 26378 # 哨兵监听的主服务器 sentinel myid 09a71e001825114de399e0b6214c4b6f5449ab3a # 3秒内mymaster没响应，则认为mymaster宕机 sentinel deny...
Redis Cluster集群模式学习
01-01
Redis Cluster 集群模式学习 Redis Cluster 是 Redis 3.0 开始推出的无中心结构集群模式，每个节点保存数据和整个集群状态，每个节点都和其他所有节点连接，官方向要求至少 6 个节点才可以保证高可用，即 3 主 3 从...
C#使用Redis示例（DEMO）
12-26
主要是对于初学者有用，讲述C#使用Redis的五种类型方法示例。 本资源的图文介绍，在博客文章上有说明。 http://blog.csdn.net/ybb350680013/article/details/53884971
.net core + redis 实用类库
11-06
封装了redis各种类： 1.redis连接 2.redis锁 3.各种构造方法 反正就是很实用 //在Redis中存储常用的5种数据类型：String,Hash,List,SetSorted set //这种方式要引用ServiceStack，ServiceStack.Interfaces，ServiceStack.ServiceInterface三个dll
c# Redis使用及封装类
08-07
c# Redis使用及封装类,记得先装redis及启用。封装类内为单例可以直接使用。
ASP.NET Core +WebAPI+MVC+Redis 模拟购物车功能
01-10
使用EFCore实现实体类，WebAPI实现业务操作，mvc实现页面展示，redis实现缓存的模拟购物车功能 需要本地有redis，vs2019，安装Core 3.1，vs2019实现的代码
MVC、EF、缓存（Cookie、redis、session、cache、application等)、Linq分页、导出
L7758521DK的博客
08-06 199
API Model Bank using System; using System.Collections.Generic; using System.ComponentModel.DataAnnotations; using System.ComponentModel.DataAnnotations.Schema; using System.Linq; using System.Web; namespace SixMonthExam.api.Models { [Table("Bank")]
Redis 内部数据结构详解(1)：dict
java的平凡之路
04-22 954
本系列基于 Redis 3.2 分支 如果你使用过Redis，一定会像我一样对它的内部实现产生兴趣。《Redis内部数据结构详解》是我准备写的一个系列，也是我个人对于之前研究Redis的一个阶段性总结，着重讲解Redis在内存中的数据结构实现（暂不涉及持久化的话题）。Redis本质上是一个数据结构服务器（data structures server），以高效的方式实现了多种现成的
EFCore对数据库的操作
韬光养晦
09-16 1025
EFCore对数据库的操作 Entity Framework (EF) Core 是轻量化、可扩展、开源和跨平台版的常用 Entity Framework 数据访问技术。 EF Core 可用作对象关系映射程序 (O/RM)，以便于 .NET 开发人员能够使用 .NET 对象来处理数据库，这样就不必经常编写大部分数据访问代码了。 模型：对于 EF Core，使用模型执行数据访问。 模型由实体类和表示数据库会话的上下文对象构成，可便于用户查询和保存数据。 有关详细信息，请参阅创建模型。 可以根据现有数据库生成
ps -ef | gref redis
sblince的博客
05-20 2092
ps -ef | gref redis：找到redis进程，查看所有关于它的进程详情。 ps:查看进程命令 -ef: -e显示所有进程， -f全格式 |：管道命令，指两个命令同时进行，指ps命令和grep命令同时执行 grep:命令就是查找。 详情请点击我 ...
6位顺序号生成_基于redis生成全局唯一id
weixin_39762666的博客
11-22 869
在应用服务器集群环境下，在单台集群下加锁不能保证生成id的唯一性。那么我们如何保证在集群环境下生成唯一id呢，办法有很多1 uuid生成全球唯一id,生成方式简单粗暴，本地生成，没有网络开销，效率高；缺点长度较长，没有递增趋势性，不易维护，常用于生成token令牌。2 zookeeper通过创建顺序节点生成全局id,在高并发场景下，性能不能很好。3 mysql自带自增生成id，oracle可...
ps -ef|grep redis
最新发布
02-22
ps -ef|grep redis 是一个常用的命令行指令，用于查找正在运行的 Redis 进程。下面是对该命令的介绍： - ps：用于显示当前正在运行的进程信息。 - -ef：选项用于显示所有进程的详细信息。 - |：管道符号，用于将前...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值