C# 使用SQLsugar搭建数据仓库

通过NuGet获取SqlSugar

SqlsugarClient访问类

    public class SugarFactory
    {
        private static string strConnectionString = string.Empty;

        #region 数据库访问对象

        /// 
        /// 数据库访问对象
        /// 
        private static SqlSugarClient db = null;

        #endregion 数据库访问对象

        #region 私有构造函数,禁止实例化

        //私有构造函数,禁止实例化
        private SugarFactory()
        {
        }

        #endregion 私有构造函数,禁止实例化

        #region 初始化SqlSugarClient

        /// 
        /// 初始化SqlSugarClient
        /// 
        /// 返回SqlSugarClient对象
        public static SqlSugarClient GetInstance()
        {
            if (strConnectionString == string.Empty)
            {
                strConnectionString = "Data Source=192.168.4.61;Initial Catalog=ReportServer;User ID=sa;Password=123456";

            }

            db = new SqlSugarClient(new ConnectionConfig()
            {
                ConnectionString = strConnectionString,
                DbType = DbType.SqlServer,
                IsAutoCloseConnection = true
            }); 

            return db;
        }

        #endregion 初始化SqlSugarClient
    }

数据访问仓库接口类

/// 
    /// 数据访问仓库接口
    /// 
    /// 实体类型
    public interface IRepositoryBase where TEntity : class
    {
        /// 
        /// 获取数据库操作实例
        /// 
        /// 返回连接对象
        SqlSugarClient GetInstance();

        /// 
        /// 插入实体 忽略NULL
        /// 
        /// 实体对象
        /// 插入成功返回true
        bool Insert(TEntity entity);

        /// 
        /// 插入实体,返回自增列的值
        /// 
        /// 实体对象
        /// 插入成功返回true
        int InsertReturnIdentity(TEntity entity);

        /// 
        /// 插入实体,返回自增列的值
        /// 
        /// 实体对象
        /// 插入成功返回true
        long InsertReturnBigIdentity(TEntity entity);

        /// 
        /// 根据唯一主键删除
        /// 
        /// 唯一主键
        /// 删除成功返回true
        bool Delete(object keyValue);

        /// 
        /// 根据表达式删除
        /// 
        /// 表达式
        /// 删除成功返回true
        bool Delete(Expression> expression);

        /// 
        /// 将实体对象更新到数据库 忽略属性为NULL
        /// 
        /// 必需包含主键并且不能为匿名对象
        /// 更新成功返回true
        bool Update(TEntity entity);

        /// 
        /// 更新或者写入
        /// 
        /// 
        /// 
        TEntity UpdateOrInsert(TEntity entity);

        /// 
        /// 检测主键对应的数据是否存在
        /// 
        /// 主键值
        /// 存在返回true,不存在返回false
        bool IsExist(int ID);

        /// 
        /// 检测主键对应的数据是否存在
        /// 
        /// 主键值
        /// 存在返回true,不存在返回false
        bool IsExist(string ID);

        /// 
        /// 根据主键查询对象实体
        /// 
        /// 主键
        /// 实体
        TEntity FindEntity(object keyValue);

        /// 
        /// 根据条件查询第一条数据
        /// 
        /// 表达式
        /// 实体
        TEntity FindFirst(Expression> expression);

        /// 
        /// 查找符合表达式的List集合
        /// 
        /// 表达式
        /// 实体集合
        List FindList(Expression> expression);

        /// 
        /// 查询所有数据
        /// 
        /// 
        List FindAllList();

        /// 
        /// 查找符合表达式的List集合
        /// 
        /// 实体集合
        List GetList(string strsql);

        /// 
        /// 查找符合表达式的List集合
        /// 
        /// 前几行
        /// 表达式
        /// 实体集合
        List FindTopList(int intTop, Expression> expression);


        /// 
        /// 获得记录数
        /// 
        /// 查询条件
        /// 查询的表名
        /// 返回ListModel
        int GetListCount(string pageWhere, string tableName);

        /// 
        /// 获得分页数据
        /// 
        /// 每页数量
        /// 第几页
        /// 查询条件
        /// 排序
        /// 查询的表名
        /// 返回ListModel
        List GetListPageData(int pageSize, int pageIndex, string pageWhere, string pageOrder, string tableName);

        /// 
        /// 获取满足表达式的记录条数
        /// 
        /// 表达式
        /// 
        int FindCount(Expression> expression);
    }

仓库基类

/// 
    /// 仓储基类
    /// 
    /// 
    public class RepositoryBase : IRepositoryBase where TEntity : class, new()
    {
        /// 
        /// 获取数据库实例,公开只要是想在外部直接是用
        /// 
        /// 返回连接对象
        public SqlSugarClient GetInstance()
        {
            return SugarFactory.GetInstance();
        }

        /// 
        /// 插入实体 忽略NULL
        /// 对于自增列的值赋值没有意义,赋值和不赋值运行效果一样
        /// 
        /// 实体对象
        /// 插入成功返回true
        public virtual bool Insert(TEntity entity)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Insertable(entity).ExecuteCommand() > 0;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        /// 
        /// 插入实体,返回自增列的值
        /// 对于自增列的值赋值没有意义,赋值和不赋值运行效果一样
        /// 
        /// 实体对象
        /// 插入成功返回true
        public virtual int InsertReturnIdentity(TEntity entity)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Insertable(entity).ExecuteReturnIdentity();
                }
            }
            catch (Exception ex)
            {
                return 0;
            }
        }

        /// 
        /// 插入实体,返回自增列的值
        /// 对于自增列的值赋值没有意义,赋值和不赋值运行效果一样
        /// 
        /// 实体对象
        /// 插入成功返回true
        public virtual long InsertReturnBigIdentity(TEntity entity)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Insertable(entity).ExecuteReturnBigIdentity();
                }
            }
            catch (Exception ex)
            {
                return 0;
            }
        }

        /// 
        /// 根据唯一主键删除
        /// 主键不存在,为False 
        /// 
        /// 唯一主键
        /// 删除成功返回true
        public virtual bool Delete(object keyValue)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Deleteable().In(keyValue).ExecuteCommand() > 0;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        /// 
        /// 根据表达式删除
        /// 
        /// 表达式
        /// 删除成功返回true
        public virtual bool Delete(Expression> expression)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Deleteable().Where(expression).ExecuteCommand() > 0;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        /// 
        /// 将实体对象更新到数据库 忽略属性为NULL
        /// 主键在数据库里不存在则返回False
        /// 没有主键则返回False
        /// 
        /// 必需包含主键并且不能为匿名对象
        /// 更新成功返回true
        public virtual bool Update(TEntity entity)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Updateable(entity).ExecuteCommand() > 0;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        /// 
        /// 将实体对象更新到数据库 忽略属性为NULL
        /// 修改主键不存在的,会新增(不包括主键的)该信息
        /// 没有主键的修改,则新增该信息
        /// 
        /// 必需包含主键并且不能为匿名对象
        /// 更新成功返回true
        public virtual TEntity UpdateOrInsert(TEntity entity)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Saveable(entity).ExecuteReturnEntity();
                }
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        /// 
        /// 检测主键对应的数据是否存在
        /// 
        /// 主键值
        /// 存在返回true,不存在返回false
        public bool IsExist(int ID)
        {
            bool ReturnResult = false;

            using (var db = GetInstance())
            {
                List list = db.Queryable().In(new int[] { ID }).ToList();
                if (list != null)
                {
                    if (list.Count == 0)
                    {
                        ReturnResult = false;
                    }
                    else
                    {
                        ReturnResult = true;
                    }
                }
                else
                {
                    ReturnResult = false;
                }
            }

            return ReturnResult;
        }

        /// 
        /// 检测主键对应的数据是否存在
        /// 
        /// 主键值
        /// 存在返回true,不存在返回false
        public bool IsExist(string ID)
        {
            bool ReturnResult = false;

            using (var db = GetInstance())
            {
                List list = db.Queryable().In(new string[] { ID }).ToList();
                if (list != null)
                {
                    if (list.Count == 0)
                    {
                        ReturnResult = false;
                    }
                    else
                    {
                        ReturnResult = true;
                    }
                }
                else
                {
                    ReturnResult = false;
                }
            }

            return ReturnResult;
        }

        /// 
        /// 根据主键查询对象实体
        /// 
        /// 主键
        /// 实体
        public virtual TEntity FindEntity(object keyValue)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable().InSingle(keyValue);
                };
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        /// 
        /// 根据条件查询第一条数据
        /// 
        /// 实体
        public virtual TEntity FindFirst(Expression> expression)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable().Where(expression).First();
                };
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        /// 
        /// 查找符合表达式的List集合
        /// 
        /// 表达式
        /// 实体集合
        public virtual List FindList(Expression> expression)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable().Where(expression).ToList();
                };
            }
            catch (Exception ex)
            {
                return new List();
            }
        }

        /// 
        /// 
        /// 
        /// 
        /// 
        public virtual List FindListReturnNull(Expression> expression)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable().Where(expression).ToList();
                };
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        /// 
        /// 查找所有List集合
        /// 
        /// 实体集合
        public virtual List FindAllList()
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable().ToList();
                };
            }
            catch (Exception ex)
            {
                return new List();
            }
        }

        /// 
        /// 查找符合条件的实体集合
        /// 
        /// sql语句
        /// 实体集合
        public virtual List GetList(string strsql)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable().Where(strsql).ToList();
                };
            }
            catch (Exception ex)
            {
                return new List();
            }
        }

        /// 
        /// 查找符合表达式的List集合
        /// 
        /// 前几行
        /// 表达式
        /// 实体集合
        public virtual List FindTopList(int intTop, Expression> expression)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable().Take(intTop).Where(expression).ToList();
                };
            }
            catch (Exception ex)
            {
                return new List();
            }
        }

        #region 获得记录数
        /// 
        /// 获得记录数
        /// 不是本表的也可以进行查询,但是建议只查本表的
        /// 
        /// 
        /// 查询条件
        /// 查询的表名 
        /// 返回ListModel
        public int GetListCount(string pageWhere, string tableName)
        {
            int ReturnVale = 0;

            using (var db = GetInstance())
            {
                try
                {
                    StringBuilder strSql = new StringBuilder();
                    strSql.Append("select * from " + tableName);
                    if (pageWhere.Trim() != "")
                    {
                        strSql.Append(" where " + pageWhere);
                    }

                    ReturnVale = db.Ado.GetInt(DataAdapterHelper.CreateCountSQL(tableName, pageWhere));
                }
                catch
                {

                }
            }

            return ReturnVale;
        }
        #endregion

        /// 
        /// 获得分页数据
        /// pageSize小于0返回空,等于0返回全部
        /// pageIndex小于1则返回第一页,大于最大页数返回最后一页
        /// pageWhere必填项,不可为"",可写为1=1
        /// pageOrder必填项,不可为"",可写为 1(等数字)或者 ID (可倒序排列 ID desc)
        /// tableName必填项,不可写其他表名
        /// 
        /// 每页数量
        /// 第几页
        /// 查询条件
        /// 排序
        /// 查询的表名
        /// 返回ListModel
        public List GetListPageData(int pageSize, int pageIndex, string pageWhere, string pageOrder, string tableName)
        {
            List ListData = new List();

            using (var db = GetInstance())
            {
                try
                {
                    StringBuilder strSql = new StringBuilder();
                    strSql.Append("select * from " + tableName);
                    if (pageWhere.Trim() != "")
                    {
                        strSql.Append(" where " + pageWhere);
                    }

                    int totalCount = 0;
                    totalCount = db.Ado.GetInt(DataAdapterHelper.CreateCountSQL(tableName, pageWhere));
                    ListData = db.Ado.SqlQuery(DataAdapterHelper.CreatePageSQL(totalCount, pageSize, pageIndex, strSql.ToString(), pageOrder, tableName));
                }
                catch (Exception ex)
                {

                }
            }

            return ListData;
        }

        /// 
        /// 获取满足表达式的记录条数
        /// 
        /// 表达式
        /// 
        public int FindCount(Expression> expression)
        {
            try
            {
                using (var db = GetInstance())
                {
                    return db.Queryable().Count(expression);
                };
            }
            catch (Exception ex)
            {
                return -1;
            }
        }
    }

DataAdapterHelper帮助类:

/// 
    /// 单表管理帮助类
    /// 
    public class DataAdapterHelper
    {
        #region 获取记录总数SQL语句
        /// 
        /// 获取记录总数SQL语句
        /// 
        /// 表名
        /// 条件
        /// 返回SQL语句
        public static string CreateCountSQL(string tableName, string pageWhere)
        {
            string ReturnValue = string.Empty;
            ReturnValue = SqlServerHelper.CreateCountSQL(tableName, pageWhere);

            return ReturnValue;
        }
        #endregion

        #region 获取分页SQL语句
        /// 
        /// 获取分页SQL语句
        /// 
        /// 记录总数
        /// 每页记录数
        /// 当前页数
        /// 查询条件
        /// 排序
        /// 表名
        /// 返回SQL语句
        public static string CreatePageSQL(int totalCount, int pageSize, int pageIndex, string pageWhere, string pageOrder, string tableName)
        {
            string ReturnValue = string.Empty;
            ReturnValue = SqlServerHelper.CreatePageSQL(totalCount, pageSize, pageIndex, pageWhere, pageOrder, tableName);

            return ReturnValue;
        }
        #endregion
    }

SqlServerHelper帮助类:

    /// 
    /// 单表管理数据操作类
    /// 
    public class SqlServerHelper
    {
        #region 获取记录总数SQL语句
        /// 
        /// 获取记录总数SQL语句
        /// 
        /// 表名
        /// 条件
        /// 返回SQL语句
        public static string CreateCountSQL(string tableName, string pageWhere)
        {
            return string.Format("SELECT COUNT(1) FROM {0} WHERE {1}", tableName, pageWhere);
        }
        #endregion

        #region 获取分页SQL语句
        /// 
        /// 获取分页SQL语句
        /// 
        /// 记录总数
        /// 每页记录数
        /// 当前页数
        /// 查询条件
        /// 排序
        /// 表名
        /// 返回SQL语句
        public static string CreatePageSQL(int totalCount, int pageSize, int pageIndex, string pageWhere, string pageOrder, string tableName)
        {
            //计算总页数
            pageSize = pageSize == 0 ? totalCount : pageSize;
            int pageCount = (totalCount + pageSize - 1) / pageSize;

            //检查当前页数
            if (pageIndex < 1)
            {
                pageIndex = 1;
            }
            else if (pageIndex > pageCount)
            {
                pageIndex = pageCount;
            }
            //拼接SQL字符串,加上ROW_NUMBER函数进行分页
            StringBuilder newSafeSql = new StringBuilder();
            newSafeSql.AppendFormat("SELECT ROW_NUMBER() OVER(ORDER BY {0}) as row_number,", pageOrder);
            newSafeSql.Append(pageWhere.Substring(pageWhere.ToUpper().IndexOf("SELECT") + 6));

            //拼接成最终的SQL语句
            StringBuilder sbSql = new StringBuilder();
            sbSql.Append("SELECT * FROM (");
            sbSql.Append(newSafeSql.ToString());
            sbSql.Append(") AS T");
            sbSql.AppendFormat(" WHERE row_number between {0} and {1}", ((pageIndex - 1) * pageSize) + 1, pageIndex * pageSize);

            return sbSql.ToString();
        }
        #endregion
    }

调用测试:

根据数据库创建表的对应实体类Roles,查询调用:

            RepositoryBase aa = new RepositoryBase();
            var bb = aa.FindAllList();

 

你可能感兴趣的:(C#,数据库,sql,数据库)