SqlSugar仓储类及其二级缓存

最新推荐文章于 2024-09-06 17:29:13 发布
最新推荐文章于 2024-09-06 17:29:13 发布
阅读量3.2k 收藏 8
点赞数 1
分类专栏： ORM 文章标签： 数据库 orm oracle
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangxin97/article/details/109511441
版权

1、引入nuget包

		install-package sqlSugar

2、仓储类

 public class BaseRepository<TEntity> : SimpleClient<TEntity> where TEntity : class, new()
    {
        private Logger loggers = Logger.CreateLogger(typeof(BaseRepository<TEntity>));
        public BaseRepository(ISqlSugarClient context = null) : base(context)
        {
            if (context == null)
            {
                // 分库处理
                Config config = Config.getBean();
                if (typeof(TEntity).GetTypeInfo().GetCustomAttributes(typeof(SugarTable), true).FirstOrDefault((x => x.GetType() == typeof(SugarTable))) is SugarTable sugarTable)
                {
                    string conncent = sugarTable.TableDescription;
                    if (string.IsNullOrWhiteSpace(conncent))  { config = Config.getBean();}
                    else{ config = Config.getBean(conncent.ToUpper());}
                }

                base.Context = new SqlSugarClient(new ConnectionConfig()
                {
                    DbType = (DbType)config.DbType,
                    InitKeyType = (InitKeyType)config.InitKeyType,
                    IsAutoCloseConnection = config.IsAutoCloseConnection,
                    ConnectionString = config.ConnectionString,
                    ConfigureExternalServices = new ConfigureExternalServices()
                    {
                        DataInfoCacheService = new HttpRuntimeCache()
                    }
                });
                base.Context.Aop.OnLogExecuting = (sql, pars) => //SQL执行中事件
                { //loggers.Warn(new LogContent("OnLogExecuting", "SQL语句打印", "SQL：" + GetParas(pars) + "【SQL语句】：" + sql));
                };
                base.Context.Aop.OnError = (e) =>{
                    loggers.Error(new LogContent("BaseRepository", "SQL异常事件", e.Message));
                };
            }
        }



        private string GetParas(SugarParameter[] pars)
        {
            string key = "【SQL参数】：";
            foreach (var param in pars)
            {
                key += $"{param.ParameterName}:{param.Value}\n";
            }

            return key;
        }
        
        internal ISqlSugarClient Db
        {
            get { return Context; }
        }
        
        public void BeginTran()
        {
            Context.Ado.BeginTran();
        }

        public void Commit()
        {
            Context.Ado.CommitTran();
        }

        public void Rollback()
        {
            Context.Ado.RollbackTran();
        }
        /// <summary>
        /// 功能描述:根据ID查新数据
        /// </summary>
        /// <param name="objId">id（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns></returns>
        public async Task<TEntity> QueryById(object objId)
        {
            return await Context.Queryable<TEntity>().In(objId).SingleAsync();
        }
        /// <summary>
        /// 功能描述:根据ID查询一条数据
        /// </summary>
        /// <param name="objId">id（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="blnUseCache">是否使用缓存</param>
        /// <returns>数据实体</returns>
        public async Task<TEntity> QueryById(object objId, bool blnUseCache = false)
        {
            return await Context.Queryable<TEntity>().WithCacheIF(blnUseCache).In(objId).SingleAsync();
        }
        /// <summary>
        /// 功能描述:根据ID查询数据
        /// </summary>
        /// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>数据实体列表</returns>
        public async Task<List<TEntity>> QueryByIDs(object[] lstIds)
        {
            return await Context.Queryable<TEntity>().In(lstIds).ToListAsync();
        }

        /// <summary>
        /// 写入实体数据
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <returns></returns>
        public async Task<long> Add(TEntity entity)
        {
            var insert = Context.Insertable(entity);
            return await insert.ExecuteReturnBigIdentityAsync();
        }

        /// <summary>
        /// 写入实体数据(同步方法)
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <returns></returns>
        public long AddSync(TEntity entity)
        {
            var insert = Context.Insertable(entity);
            return insert.ExecuteReturnBigIdentity();
        }


        /// <summary>
        /// 写入实体数据
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <param name="insertColumns">指定只插入列</param>
        /// <returns>返回自增量列</returns>
        public async Task<int> Add(TEntity entity, Expression<Func<TEntity, object>> insertColumns = null)
        {
            var insert = Context.Insertable(entity);
            if (insertColumns == null)
            {
                return await insert.ExecuteReturnIdentityAsync();
            }
            else
            {
                return await insert.InsertColumns(insertColumns).ExecuteReturnIdentityAsync();
            }
        }

        /// <summary>
        /// 写入实体数据
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <returns>返回被影响的行数</returns>
        public async Task<int> AddByRows(TEntity entity)
        {
            var insert = Context.Insertable(entity);
            return await insert.ExecuteCommandAsync();
        }
        /// <summary>
        /// 写入实体数据
        /// </summary>
        /// <param name="listEntity">实体类集合</param>
        /// <returns>返回被影响的行数</returns>
        public int AddByRows(List<TEntity> listEntity)
        {
            return Context.Insertable(listEntity.ToArray()).ExecuteCommand();
        }

        /// <summary>
        /// 批量插入实体(速度快)
        /// </summary>
        /// <param name="listEntity">实体集合</param>
        /// <returns>影响行数</returns>
        public async Task<int> Add(List<TEntity> listEntity)
        {
            return await Context.Insertable(listEntity.ToArray()).ExecuteCommandAsync();
        }

        public int AddSync(List<TEntity> listEntity)
        {
            return Context.Insertable(listEntity.ToArray()).ExecuteCommand();
        }


        /// <summary>
        /// 更新实体数据
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <returns></returns>
        public async Task<bool> Update(TEntity entity)
        {
            //这种方式会以主键为条件
            return await Context.Updateable(entity).ExecuteCommandHasChangeAsync();
        }
        public bool Update(List<TEntity> entities)
        {
            return Context.Updateable(entities).ExecuteCommandHasChange();
        }
        /// <summary>
        /// 同步 更新
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public int UpdateSync(TEntity entity)
        {
            //这种方式会以主键为条件
            return Context.Updateable(entity).ExecuteCommand();
        }
        /// <summary>
        /// 同步 更新批量
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public int UpdateSync(List<TEntity> entities)
        {
            return Context.Updateable(entities).ExecuteCommand();
        }



        /// <summary>
        /// 异步 更新实体
        /// </summary>
        /// <param name="entities"></param>
        /// <returns></returns>
        public async Task<int> UpdateAsync(List<TEntity> entities)
        {

            return await Context.Updateable(entities).ExecuteCommandAsync();

        }

        public async Task<bool> Update(TEntity entity, string strWhere)
        {
            return await Context.Updateable(entity).Where(strWhere).ExecuteCommandHasChangeAsync();
        }

        public async Task<bool> Update(string strSql, SugarParameter[] parameters = null)
        {
            return await Context.Ado.ExecuteCommandAsync(strSql, parameters) > 0;
        }

        public async Task<bool> Update(object operateAnonymousObjects)
        {
            return await Context.Updateable<TEntity>(operateAnonymousObjects).ExecuteCommandAsync() > 0;
        }

        public async Task<bool> Update(
          TEntity entity,
          List<string> lstColumns = null,
          List<string> lstIgnoreColumns = null,
          string strWhere = ""
            )
        {
            IUpdateable<TEntity> up = Context.Updateable(entity);
            if (lstIgnoreColumns != null && lstIgnoreColumns.Count > 0)
            {
                up = up.IgnoreColumns(lstIgnoreColumns.ToArray());
            }
            if (lstColumns != null && lstColumns.Count > 0)
            {
                up = up.UpdateColumns(lstColumns.ToArray());
            }
            if (!string.IsNullOrEmpty(strWhere))
            {
                up = up.Where(strWhere);
            }
            return await up.ExecuteCommandHasChangeAsync();
        }

        /// <summary>
        /// 根据实体删除一条数据
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <returns></returns>
        public async Task<bool> Delete(TEntity entity)
        {
            return await Context.Deleteable(entity).ExecuteCommandHasChangeAsync();
        }

        /// <summary>
        /// 删除指定ID的数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        public async Task<bool> DeleteById(object id)
        {
            return await Context.Deleteable<TEntity>(id).ExecuteCommandHasChangeAsync();
        }

        /// <summary>
        /// 删除指定ID集合的数据(批量删除)
        /// </summary>
        /// <param name="ids">主键ID集合</param>
        /// <returns></returns>
        public async Task<bool> DeleteByIds(object[] ids)
        {
            return await Context.Deleteable<TEntity>().In(ids).ExecuteCommandHasChangeAsync();
        }



        /// <summary>
        /// 功能描述:查询所有数据
        /// </summary>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query()
        {
            return await Context.Queryable<TEntity>().ToListAsync();
        }

        /// <summary>
        /// 功能描述:查询数据列表
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(string strWhere)
        {
            return await Context.Queryable<TEntity>().WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToListAsync();
        }

        /// <summary>
        /// 功能描述:查询数据列表
        /// </summary>
        /// <param name="whereExpression">whereExpression</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression)
        {
            return await Context.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).ToListAsync();
        }
        public async Task<TEntity> QueryFist(Expression<Func<TEntity, bool>> whereExpression)
        {
            return await Context.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).FirstAsync();
        }

        /// <summary>
        /// 功能描述:查询一个列表
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, string strOrderByFileds)
        {
            return await Context.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).OrderByIF(strOrderByFileds != null, strOrderByFileds).ToListAsync();
        }
        /// <summary>
        /// 功能描述:查询一个列表
        /// </summary>
        /// <param name="whereExpression"></param>
        /// <param name="orderByExpression"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, object>> orderByExpression, bool isAsc = true)
        {
            return await Context.Queryable<TEntity>().OrderByIF(orderByExpression != null, orderByExpression, isAsc ? OrderByType.Asc : OrderByType.Desc).WhereIF(whereExpression != null, whereExpression).ToListAsync();
        }

        /// <summary>
        /// 功能描述:查询一个列表
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(string strWhere, string strOrderByFileds)
        {
            return await Context.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToListAsync();
        }


        /// <summary>
        /// 功能描述:查询前N条数据
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="intTop">前N条</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(
            Expression<Func<TEntity, bool>> whereExpression,
            int intTop,
            string strOrderByFileds)
        {
            return await Context.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression).Take(intTop).ToListAsync();
        }

        /// <summary>
        /// 功能描述:查询前N条数据
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="intTop">前N条</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(
            string strWhere,
            int intTop,
            string strOrderByFileds)
        {
            return await Context.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).Take(intTop).ToListAsync();
        }



        /// <summary>
        /// 功能描述:分页查询
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="intPageIndex">页码（下标0）</param>
        /// <param name="intPageSize">页大小</param>
        /// <param name="intTotalCount">数据总量</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(
            Expression<Func<TEntity, bool>> whereExpression,
            int intPageIndex,
            int intPageSize,
            string strOrderByFileds)
        {
            return await Context.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression).ToPageListAsync(intPageIndex, intPageSize);
        }

        /// <summary>
        /// 功能描述:分页查询
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="intPageIndex">页码（下标0）</param>
        /// <param name="intPageSize">页大小</param>
        /// <param name="intTotalCount">数据总量</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(
          string strWhere,
          int intPageIndex,
          int intPageSize,

          string strOrderByFileds)
        {

            return await Context.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToPageListAsync(intPageIndex, intPageSize);
        }




        /// <summary> 
        ///查询-多表查询
        /// </summary> 
        /// <typeparam name="T">实体1</typeparam> 
        /// <typeparam name="T2">实体2</typeparam> 
        /// <typeparam name="T3">实体3</typeparam>
        /// <typeparam name="TResult">返回对象</typeparam>
        /// <param name="joinExpression">关联表达式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param> 
        /// <param name="selectExpression">返回表达式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
        /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param> 
        /// <returns>值</returns>
        public async Task<List<TResult>> QueryMuch<T, T2, T3, TResult>(
            Expression<Func<T, T2, T3, object[]>> joinExpression,
            Expression<Func<T, T2, T3, TResult>> selectExpression,
            Expression<Func<T, T2, T3, bool>> whereLambda = null) where T : class, new()
        {
            if (whereLambda == null)
            {
                return await Context.Queryable(joinExpression).Select(selectExpression).ToListAsync();
            }
            return await Context.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).ToListAsync();
        }

        /// <summary>
        /// 根据Sql查询集合
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> QuerySql(string sql)
        {
            return await Context.SqlQueryable<TEntity>(sql).ToListAsync();
        }





        /// <summary>
        /// ADO 查询
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> SqlQueryTolist(string sql)
        {
            return await Context.Ado.SqlQueryAsync<TEntity>(sql);
        }
        /// <summary>
        /// ADO 查询
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public async Task<List<T>> SqlQueryTolist<T>(string sql)
        {
            return await Context.Ado.SqlQueryAsync<T>(sql);
        }


        /// <summary>
        /// ADO 查询
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public async Task<TEntity> SqlQuery(string sql)
        {
            return await Context.Ado.SqlQuerySingleAsync<TEntity>(sql);
        }
        /// <summary>
        /// ADO 查询
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="pairs"></param>
        /// <returns></returns>
        public async Task<T> SqlQuery<T>(string sql)
        {
            return await Context.Ado.SqlQuerySingleAsync<T>(sql);
        }

        /// <summary>
        /// 查询返回 集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <returns>返回List 集合</returns>
        public async Task<List<T>> SqlQuerys<T>(string sql)
        {
            return await Context.Ado.SqlQueryAsync<T>(sql);
        }

        /// <summary>
        /// ADO 查询
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="pairs"></param>
        /// <returns>返回List 集合</returns>
        public async Task<List<T>> SqlQuery<T>(string sql, Dictionary<string, object> pairs)
        {
            return await Context.Ado.SqlQueryAsync<T>(sql, FormationParameter(pairs).ToArray());
        }
        /// <summary>
        /// ADO 查询
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="pairs"></param>
        /// <returns>返回List 集合</returns>
        public async Task<List<TEntity>> SqlQuery(string sql, Dictionary<string, object> pairs)
        {
            return await Context.Ado.SqlQueryAsync<TEntity>(sql, FormationParameter(pairs).ToArray());
        }

        /// <summary>
        /// ADO 执行 增删改方法
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public async Task<int> ExecuteCommand(string sql)
        {
            return await Context.Ado.ExecuteCommandAsync(sql);
        }



        /// <summary>
        /// ADO 执行 增删改方法
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="pairs"></param>
        /// <returns></returns>
        public async Task<int> ExecuteCommand(string sql, Dictionary<string, object> pairs)
        {
            return await Context.Ado.ExecuteCommandAsync(sql, FormationParameter(pairs).ToArray());
        }




        /// <summary>
        /// 获取序列自增ID
        /// </summary>
        /// <param name="tname">序列名</param>
        /// <param name="sequenceName">对应表名称</param>
        /// <returns></returns>
        public long getquery_id(string sequenceName, string tableName)
        {
            long myvar = 0;
            while (true)
            {
                string sql = "select " + sequenceName + ".NEXTVAL from dual ";
                try
                {
                    myvar = Context.Ado.SqlQuerySingle<long>(sql);

                    if (myvar > 0)
                    {
                        sql = "select count(*) from " + tableName + " where ID=" + myvar.ToString();
                        long myids = Context.Ado.SqlQuerySingle<long>(sql);
                        if (myids == 0)
                        {
                            break;
                        }
                    }
                }
                catch (Exception ex)
                {
                    loggers.Error(new LogContent("getquery_id", "获取序列异常", $"【序列获取失败】：{ex.Message}"));
                }
            }
            return myvar;
        }



        private List<SugarParameter> FormationParameter(Dictionary<string, object> pairs)
        {
            List<SugarParameter> olist = new List<SugarParameter>();
            if (pairs.Count > 0)
            {
                foreach (var item in pairs.Keys)
                {
                    olist.Add(new SugarParameter(item, pairs[item].ToString()));
                }
            }
            return olist;
        }

        /// <summary>
        ///  执行包体 方法（存储过程）
        /// </summary>
        /// <param name="packFuncName">imr_pkg_mr_data_syn.SP_SYN_SYS_USERS</param>
        /// <returns></returns>
        public System.Data.DataTable ExecStoredProcedure(string packFuncName, List<SugarParameter> olist)
        {
            try
            {

                System.Data.DataTable pack = Context.Ado.UseStoredProcedure().GetDataTable(packFuncName, olist.ToArray());
                return pack;
            }
            catch (Exception err)
            {

                throw err;
            }



        }


    }

3、配置文件

{
  "SqlSugarClient": [
    {
      "DbType": "3",
      "Connection": "User Id=TEST;Password=123456;Data Source=(DESCRIPTION=(ADDRESS=(PROTOCOL=tcp)(HOST=127.0.0.1)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=orcl)));Max Pool Size=512;Pooling=true",
      "InitKeyType":"1"
    }
  ],
  "SqlSugarClient2": [
    {
      "DbType": "3",
      "Connection": "User Id=TEST2;Password=123456;Data Source=(DESCRIPTION=(ADDRESS=(PROTOCOL=tcp)(HOST=127.0.0.1)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=orcl)));Max Pool Size=512;Pooling=true",
      "InitKeyType":"1"
    }
  ]
}

4、自定义读取json 文件

    public class Config
    {

        /// <summary>
        /// 数据库连接
        /// </summary>
        public string ConnectionString { get; set; }

        /// <summary>
        /// 数据库类型
        /// </summary>
        public int DbType { get; set; }

        /// <summary>
        /// 默认读取实体表方式
        /// </summary>
        public int InitKeyType { get; set; }

        /// <summary>
        /// 是否自动提交事务
        /// </summary>
        public bool IsAutoCloseConnection { get; set; }

        /// <summary>
        /// 获取ConnectionConfig
        /// </summary>
        /// <returns></returns>
        public static Config getBean(string connectName = "SqlSugarClient")
        {
            string path = "";
            if (HttpContext.Current != null)
            {
                path = HttpContext.Current.Server.MapPath("/DbConfig.json");
            }
            else
            {
                path = Path.Combine(AppDomain.CurrentDomain.SetupInformation.ApplicationBase + "DbConfig.json");
            }
            using (StreamReader r = new StreamReader(path))
            {
                string json = r.ReadToEnd();
                JObject obj = JObject.Parse(json);
                var jToken = obj[$"{connectName}"][0];
                var conf = new Config()
                {
                    DbType = Convert.ToInt32(jToken["DbType"]),
                    ConnectionString = jToken["Connection"].ToString(),
                    InitKeyType = Convert.ToInt32(jToken["InitKeyType"]),
                    IsAutoCloseConnection = true
                };

                return conf;
            }

        }

    }

5、二级缓存类（SqlSugar官网提供）

 /// <summary>
    ///  二级缓存
    /// </summary>
    public class HttpRuntimeCache : ICacheService
    {
        public void Add<V>(string key, V value)
        {
            HttpRuntimeCacheHelper<V>.GetInstance().Add(key, value);
        }

        public void Add<V>(string key, V value, int cacheDurationInSeconds)
        {
            HttpRuntimeCacheHelper<V>.GetInstance().Add(key, value, cacheDurationInSeconds);
        }

        public bool ContainsKey<V>(string key)
        {
            return HttpRuntimeCacheHelper<V>.GetInstance().ContainsKey(key);
        }

        public V Get<V>(string key)
        {
            return HttpRuntimeCacheHelper<V>.GetInstance().Get(key);
        }

        public IEnumerable<string> GetAllKey<V>()
        {
            return HttpRuntimeCacheHelper<V>.GetInstance().GetAllKey();
        }

        public V GetOrCreate<V>(string cacheKey, Func<V> create, int cacheDurationInSeconds = int.MaxValue)
        {
            var cacheManager = HttpRuntimeCacheHelper<V>.GetInstance();
            if (cacheManager.ContainsKey(cacheKey))
            {
                return cacheManager[cacheKey];
            }
            else
            {
                var result = create();
                cacheManager.Add(cacheKey, result, cacheDurationInSeconds);
                return result;
            }
        }

        public void Remove<V>(string key)
        {
            HttpRuntimeCacheHelper<V>.GetInstance().Remove(key);
        }
    }

    internal class HttpRuntimeCacheHelper<V>
    {

        #region 全局变量
        private static HttpRuntimeCacheHelper<V> _instance = null;
        private static readonly object _instanceLock = new object();
        #endregion

        #region 构造函数

        private HttpRuntimeCacheHelper() { }
        #endregion

        #region  属性
        /// <summary>         
        ///根据key获取value     
        /// </summary>         
        /// <value></value>      
        public V this[string key]
        {
            get { return (V)HttpRuntime.Cache[CreateKey(key)]; }
        }
        #endregion

        #region 公共函数

        /// <summary>         
        /// key是否存在       
        /// </summary>         
        /// <param name="key">key</param>         
        /// <returns> ///  存在<c>true</c> 不存在<c>false</c>.        /// /// </returns>         
        public bool ContainsKey(string key)
        {
            return HttpRuntime.Cache[CreateKey(key)] != null;
        }

        /// <summary>         
        /// 获取缓存值         
        /// </summary>         
        /// <param name="key">key</param>         
        /// <returns></returns>         
        public V Get(string key)
        {
            return (V)HttpRuntime.Cache.Get(CreateKey(key));
        }

        /// <summary>         
        /// 获取实例 （单例模式）       
        /// </summary>         
        /// <returns></returns>         
        public static HttpRuntimeCacheHelper<V> GetInstance()
        {
            if (_instance == null)
                lock (_instanceLock)
                    if (_instance == null)
                        _instance = new HttpRuntimeCacheHelper<V>();
            return _instance;
        }

        /// <summary>         
        /// 插入缓存(默认20分钟)        
        /// </summary>         
        /// <param name="key"> key</param>         
        /// <param name="value">value</param>          
        public void Add(string key, V value)
        {
            Add(key, value, 60 * 20);
        }

        /// <summary>         
        /// 插入缓存        
        /// </summary>         
        /// <param name="key"> key</param>         
        /// <param name="value">value</param>         
        /// <param name="cacheDurationInSeconds">过期时间单位秒</param>         
        public void Add(string key, V value, int cacheDurationInSeconds)
        {
            Add(key, value, cacheDurationInSeconds, CacheItemPriority.Default);
        }

        /// <summary>         
        /// 插入缓存.         
        /// </summary>         
        /// <param name="key">key</param>         
        /// <param name="value">value</param>         
        /// <param name="cacheDurationInSeconds">过期时间单位秒</param>         
        /// <param name="priority">缓存项属性</param>         
        public void Add(string key, V value, int cacheDurationInSeconds, CacheItemPriority priority)
        {
            string keyString = CreateKey(key);
            HttpRuntime.Cache.Insert(keyString, value, null,
            DateTime.Now.AddSeconds(cacheDurationInSeconds), Cache.NoSlidingExpiration, priority, null);
        }

        /// <summary>         
        /// 插入缓存.         
        /// </summary>         
        /// <param name="key">key</param>         
        /// <param name="value">value</param>         
        /// <param name="cacheDurationInSeconds">过期时间单位秒</param>         
        /// <param name="priority">缓存项属性</param>         
        public void Add(string key, V value, int
         cacheDurationInSeconds, CacheDependency dependency, CacheItemPriority priority)
        {
            string keyString = CreateKey(key);
            HttpRuntime.Cache.Insert(keyString, value,
             dependency, DateTime.Now.AddSeconds(cacheDurationInSeconds), Cache.NoSlidingExpiration, priority, null);
        }

        /// <summary>         
        /// 删除缓存         
        /// </summary>         
        /// <param name="key">key</param>         
        public void Remove(string key)
        {
            HttpRuntime.Cache.Remove(CreateKey(key));
        }

        /// <summary>
        /// 清除所有缓存
        /// </summary>
        public void RemoveAll()
        {
            System.Web.Caching.Cache cache = HttpRuntime.Cache;
            IDictionaryEnumerator CacheEnum = cache.GetEnumerator();
            ArrayList al = new ArrayList();
            while (CacheEnum.MoveNext())
            {
                al.Add(CacheEnum.Key);
            }
            foreach (string key in al)
            {
                cache.Remove(key);
            }
        }

        /// <summary>
        /// 清除所有包含关键字的缓存
        /// </summary>
        /// <param name="removeKey">关键字</param>
        public void RemoveAll(Func<string, bool> removeExpression)
        {
            System.Web.Caching.Cache _cache = HttpRuntime.Cache;
            var allKeyList = GetAllKey();
            var delKeyList = allKeyList.Where(removeExpression).ToList();
            foreach (var key in delKeyList)
            {
                HttpRuntime.Cache.Remove(key); ;
            }
        }

        /// <summary>
        /// 获取所有缓存key
        /// </summary>
        /// <returns></returns>
        public IEnumerable<string> GetAllKey()
        {
            IDictionaryEnumerator CacheEnum = HttpRuntime.Cache.GetEnumerator();
            while (CacheEnum.MoveNext())
            {
                yield return CacheEnum.Key.ToString();
            }
        }
        #endregion

        #region 私有函数

        /// <summary>         
        ///创建KEY   
        /// </summary>         
        /// <param name="key">Key</param>         
        /// <returns></returns>         
        private string CreateKey(string key)
        {
            return key;
        }
        #endregion
    }
驯鹿的熊猫人
关注
专栏目录
.net6 SqlSugar配置及增删改查（webapi项目）
weixin_67890610的博客
12-09 1693
可以放在一个控制台程序中，需要的时候在运行就好。
使用SqlSugar封装的数据层基类
dengxuanxian9113的博客
06-02 3664
首先简单封装了个DbContext 1 public class DbContext 2 { 3 #region 属性字段 4 private static string _connectionString; 5 6 /// <summary> 7 /...
有关sqlsugar的缓存机制
最新发布
m0_73847536的博客
09-06 997
内存缓存（Memory Cache）文件系统缓存分布式缓存（如 Memcached 或其他 NoSQL 缓存）数据库缓存。
mysql的数据层基类_使用SqlSugar封装的数据层基类
weixin_30833209的博客
01-19 574
public class BaseDal where T : class ,new(){#region 属性字段privateDbContext _context;publicDbContext Context{get { return_context; }set { _context =value; }}privateSqlSugarClient _db;/// ///数据处理对象 by bec...
mysql basedal_使用SqlSugar封装的数据层基类
weixin_30358181的博客
01-19 303
public class BaseDal where T : class ,new(){#region 属性字段privateDbContext _context;publicDbContext Context{get { return_context; }set { _context =value; }}privateSqlSugarClient _db;/// ///数据处理对象 by bec...
ORM C# 封装SqlSugar 操作数据库
爱分享的小猿
08-31 2036
ORM C# 使用SqlSugar操作数据库
C#.net8创建webapi，使用SqlSugar，仓储模式，DTO，服务层，控制层的综合应用
03-26
在本文中，我们将深入探讨如何使用C#.NET 8创建一个Web API，同时结合SqlSugar作为ORM工具，以及实现仓储模式、DTO（Data Transfer Object）转换、服务层和服务控制层的架构设计。这个综合应用旨在提供一个高效且可...
实现sqlsugar类生成器
03-05
SqlSugar是一款轻量级、高性能的ORM（对象关系映射）框架，专为.NET平台设计。它极大地简化了数据库操作，使开发者能够使用C#或VB.NET等高级语言编写SQL语句，而无需直接与数据库的原生SQL交互。本项目“实现...
SqlSugarRepository接口与实现 for .net core
11-26
对应表的仓储接口继承ISqlSugarRepository 对应表的仓储实现继承...这两个类是在 .net Standard2.1类库中创建的 仓储包含基础的增删改查操作，及使用sql语句的实现 （需要nuget：SqlSugar.IOC和SqlSugarCore）
C# SqlSugar多数据库仓储模式中的缓存优化策略
在本章中，我们将介绍C# SqlSugar多数据库仓储模式的背景和概述，探讨缓存优化策略的重要性，并概述本文的结构和目标。让我们一起深入了解这些内容。 # 2. C# SqlSugar多数据库仓储模式概述 在本章中，我们将介绍...
基于SqlSuagr封装的辅助类
05-21
基于SqlSuagr封装的辅助类
一套使用sqlsugar的企业级web应用框架
03-24
该程序是一套集成了管理软件系统前后台框架，底层使用了国内孙凯旋开发的sqlsugar数据模型框架，该框架吸收了EF中使用lambda表达式的查询方式,同时性能上与手写sql的Dapper框架同样高效，可以说是.net数据模型里最成熟的框架。该系统是作者（王立群）经过多个项目，不断优化改进而提炼形成，实现了菜单管理，用户角色管理的基础框架。开发者可以在此基础上按照系统设计好的分层与数据访问方式，快速构建企业级web应用系统。
SqlSugar生成实体类Demo
12-04
sqlsugar怎么利用t4模板生成实体类；以及sqlsugar简单的增删改查。自己整理的，方便以后查找
轻量级、高性能SQL ORM 之 SqlSugar.zip
07-19
SqlSugar ORM优点： 1、高性能，达到原生最高水准，比SqlHelper性能要高，比Dapper快30% 比EF快50% 2、支持多种数据库 ，sql版本更新最快，其它会定期更新，可以在多种数据库用一种编程方式 3、支持.net Core 4、支持多库并行计算 5、带有实体生成函数和T4模版生成实体 6、无需任何配置 ，还你一个干净的model，可以没有主键 ，也可以有多个主键 ，或者多个自增列     代码片段包下载地址  https://github.com/sunkaixuan/SqlSugarSnippets  SqlSugar ORM教程和下载地址 http://www.cnblogs.com/sunkaixuan/p/5654695.html 性能测试： 标签：orm
SqlSugar-dev
10-19
2. **代码生成器**：SqlSugar提供了代码生成工具，可以帮助开发者自动生成实体类、仓储接口及实现，大大提高了开发效率。 3. **查询构建器**：SqlSugar支持动态和静态两种查询方式。动态查询允许开发者在运行时构建...
基于SqlSugar的开发框架逐步介绍 - 在基类函数封装中实现用户操作日志记录 (.NET)
RzuScala的博客
09-21 296
在上述代码中，我们创建了一个名为"BaseRepository"的基类，并通过构造函数接受一个SqlSugarClient对象，用于执行数据库操作。在上述代码中，我们创建了一个名为"BaseRepository"的基类，并通过构造函数接受一个SqlSugarClient对象，用于执行数据库操作。接下来，我们创建一个基类（例如名为"BaseRepository"），用于封装数据库操作的公共逻辑，并在其中实现用户操作日志记录的功能。接下来，创建一个名为"UserLog"的实体类，与数据库表中的字段对应。
C#给SqlSugar封装一个单例类
csdn2990的博客
06-28 457
可以直接用，轻量方便，无需重复造轮子。这里只对CRUD进行封装，我的应用比较简单。
C# SqlSugar框架的学习使用（七）-- 二级缓存的使用
Vaccae的博客
08-26 3276
前言上一篇《C# SqlSugar框架的学习使用（六）-- 扩展用法》把一些常用的扩展用法已经做了出来，本篇就来讲一下SqlSugar高级用法中的二级缓存功能。二级缓存功能介绍及使用方法...
sqlsugar仓储
12-01
在SqlSugar中，仓储模式由两个类实现：ISqlSugarRepository和SqlSugarRepository。 ISqlSugarRepository是一个接口，定义了基本的增删改查操作，例如Insert、Update、Delete和Query等。SqlSugarRepository是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值