/***********************************************************************
|
* Project: CoreCms
|
* ProjectName: 核心内容管理系统
|
* Web: https://www.corecms.net
|
* Author: 大灰灰
|
* Email: jianweie@163.com
|
* CreateTime: 2021/1/31 21:45:10
|
* Description: 暂无
|
***********************************************************************/
|
|
using System;
|
using System.Collections.Generic;
|
using System.Data;
|
using System.Linq.Expressions;
|
using System.Threading.Tasks;
|
using CoreCms.Net.IRepository;
|
using CoreCms.Net.IRepository.UnitOfWork;
|
using CoreCms.Net.Model.ViewModels.Basics;
|
using SqlSugar;
|
|
namespace CoreCms.Net.Repository
|
{
|
public abstract class BaseRepository<T> : IBaseRepository<T> where T : class, new()
|
{
|
//private readonly IUnitOfWork _unitOfWork;
|
private readonly SqlSugarScope _dbBase;
|
|
protected BaseRepository(IUnitOfWork unitOfWork)
|
{
|
//_unitOfWork = unitOfWork;
|
_dbBase = unitOfWork.GetDbClient();
|
}
|
|
private ISqlSugarClient DbBaseClient => _dbBase;
|
|
protected ISqlSugarClient DbClient => DbBaseClient;
|
|
#region 查询数据
|
|
/// <summary>
|
/// 根据主值查询单条数据
|
/// </summary>
|
/// <param name="pkValue">主键值</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns>泛型实体</returns>
|
public T QueryById(object pkValue, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return DbBaseClient.Queryable<T>().WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).InSingle(pkValue);
|
}
|
|
/// <summary>
|
/// 根据主值查询单条数据
|
/// </summary>
|
/// <param name="objId">id（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns>数据实体</returns>
|
public async Task<T> QueryByIdAsync(object objId, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return await DbBaseClient.Queryable<T>().In(objId).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).SingleAsync();
|
}
|
|
/// <summary>
|
/// 根据主值列表查询单条数据
|
/// </summary>
|
/// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
|
/// <returns>数据实体列表</returns>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
public List<T> QueryByIDs(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return DbBaseClient.Queryable<T>().In(lstIds).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToList();
|
}
|
|
/// <summary>
|
/// 根据主值列表查询单条数据
|
/// </summary>
|
/// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
|
/// <returns>数据实体列表</returns>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
public async Task<List<T>> QueryByIDsAsync(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return await DbBaseClient.Queryable<T>().In(lstIds).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToListAsync();
|
}
|
|
/// <summary>
|
/// 根据主值列表查询单条数据
|
/// </summary>
|
/// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
|
/// <returns>数据实体列表</returns>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
public List<T> QueryByIDs(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return DbBaseClient.Queryable<T>().In(lstIds).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToList();
|
}
|
|
/// <summary>
|
/// 根据主值列表查询单条数据
|
/// </summary>
|
/// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
|
/// <returns>数据实体列表</returns>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
public async Task<List<T>> QueryByIDsAsync(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return await DbBaseClient.Queryable<T>().In(lstIds).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToListAsync();
|
}
|
|
/// <summary>
|
/// 查询表单所有数据(无分页,请慎用)
|
/// </summary>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public List<T> Query(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return DbBaseClient.Queryable<T>().WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToList();
|
}
|
|
/// <summary>
|
/// 查询表单所有数据(无分页,请慎用)
|
/// </summary>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public async Task<List<T>> QueryAsync(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return await DbBaseClient.Queryable<T>().WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToListAsync();
|
}
|
|
/// <summary>
|
/// 根据条件查询数据
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="orderByPredicate">排序字段</param>
|
/// <param name="orderByType">排序顺序</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns>泛型实体集合</returns>
|
public List<T> QueryListByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate = null, OrderByType orderByType = OrderByType.Asc, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return DbBaseClient.Queryable<T>()
|
.OrderByIF(orderByPredicate != null, orderByPredicate, orderByType)
|
.WhereIF(predicate != null, predicate)
|
.WithNoLockOrNot(blUseNoLock)
|
.WithCacheIF(isDataCache, cacheTimes)
|
.ToList();
|
}
|
|
/// <summary>
|
/// 根据条件查询数据
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="orderByPredicate">排序字段</param>
|
/// <param name="orderByType">排序顺序</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns>泛型实体集合</returns>
|
public async Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate = null, OrderByType orderByType = OrderByType.Asc, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return await DbBaseClient.Queryable<T>()
|
.OrderByIF(orderByPredicate != null, orderByPredicate, orderByType)
|
.WhereIF(predicate != null, predicate)
|
.WithNoLockOrNot(blUseNoLock)
|
.WithCacheIF(isDataCache, cacheTimes)
|
.ToListAsync();
|
}
|
|
/// <summary>
|
/// 根据条件查询一定数量数据
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="take">获取数量</param>
|
/// <param name="orderByPredicate">排序字段</param>
|
/// <param name="orderByType">排序顺序</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public List<T> QueryListByClause(Expression<Func<T, bool>> predicate, int take, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return DbBaseClient.Queryable<T>()
|
.OrderByIF(orderByPredicate != null, orderByPredicate, orderByType)
|
.WhereIF(predicate != null, predicate)
|
.Take(take)
|
.WithNoLockOrNot(blUseNoLock)
|
.WithCacheIF(isDataCache, cacheTimes)
|
.ToList();
|
}
|
|
/// <summary>
|
/// 根据条件查询一定数量数据
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="take">获取数量</param>
|
/// <param name="orderByPredicate">排序字段</param>
|
/// <param name="orderByType">排序顺序</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public async Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, int take, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return await DbBaseClient.Queryable<T>()
|
.OrderByIF(orderByPredicate != null, orderByPredicate, orderByType)
|
.WhereIF(predicate != null, predicate)
|
.Take(take)
|
.WithNoLockOrNot(blUseNoLock)
|
.WithCacheIF(isDataCache, cacheTimes)
|
.ToListAsync();
|
}
|
|
/// <summary>
|
/// 根据条件查询数据
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public T QueryByClause(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return DbBaseClient.Queryable<T>()
|
.WithNoLockOrNot(blUseNoLock)
|
.WithCacheIF(isDataCache, cacheTimes)
|
.First(predicate);
|
}
|
|
/// <summary>
|
/// 根据条件查询数据
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <param name="blUseTranLock">是否使用锁</param>
|
/// <param name="dbLockType">数据锁类型</param>
|
/// <returns></returns>
|
public async Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue, bool blUseTranLock = false, DbLockType dbLockType = DbLockType.Wait)
|
{
|
return await DbBaseClient.Queryable<T>().WithNoLockOrNot(blUseNoLock).WithUseTranLockOrNot(blUseTranLock, dbLockType).WithCacheIF(isDataCache, cacheTimes).FirstAsync(predicate);
|
}
|
|
/// <summary>
|
/// 根据条件查询数据
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="orderByPredicate">排序字段</param>
|
/// <param name="orderByType">排序顺序</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public T QueryByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return DbBaseClient.Queryable<T>().OrderBy(orderByPredicate, orderByType).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).First(predicate);
|
}
|
|
/// <summary>
|
/// 根据条件查询数据
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="orderByPredicate">排序字段</param>
|
/// <param name="orderByType">排序顺序</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <param name="blUseTranLock">是否使用锁</param>
|
/// <param name="dbLockType">数据锁类型</param>
|
/// <returns></returns>
|
public async Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue, bool blUseTranLock = false, DbLockType dbLockType = DbLockType.Wait)
|
{
|
return await DbBaseClient.Queryable<T>().OrderBy(orderByPredicate, orderByType).WithNoLockOrNot(blUseNoLock).WithUseTranLockOrNot(blUseTranLock, dbLockType).WithCacheIF(isDataCache, cacheTimes).FirstAsync(predicate);
|
}
|
|
#endregion
|
|
#region 新增数据
|
|
/// <summary>
|
/// 写入实体数据
|
/// </summary>
|
/// <param name="entity">实体数据</param>
|
/// <param name="isRemoveDataCache">是否删除cache</param>
|
/// <returns></returns>
|
public int Insert(T entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Insertable(entity).RemoveDataCache().ExecuteReturnIdentity() : DbBaseClient.Insertable(entity).ExecuteReturnIdentity();
|
}
|
|
/// <summary>
|
/// 写入实体数据
|
/// </summary>
|
/// <param name="entity">实体数据</param>
|
/// <param name="isRemoveDataCache">是否删除cache</param>
|
/// <returns></returns>
|
public async Task<int> InsertAsync(T entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Insertable(entity).RemoveDataCache().ExecuteReturnIdentityAsync()
|
: await DbBaseClient.Insertable(entity).ExecuteReturnIdentityAsync();
|
}
|
|
/// <summary>
|
/// 写入实体数据
|
/// </summary>
|
/// <param name="entity">实体数据</param>
|
/// <param name="insertColumns">插入的列</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public int Insert(T entity, Expression<Func<T, object>> insertColumns, bool isRemoveDataCache = false)
|
{
|
var insert = DbBaseClient.Insertable(entity);
|
return isRemoveDataCache
|
?
|
insertColumns == null
|
? insert.RemoveDataCache().ExecuteReturnIdentity()
|
: insert.RemoveDataCache().InsertColumns(insertColumns).ExecuteReturnIdentity()
|
: insertColumns == null
|
? insert.ExecuteReturnIdentity()
|
: insert.InsertColumns(insertColumns).ExecuteReturnIdentity();
|
}
|
|
/// <summary>
|
/// 写入实体数据
|
/// </summary>
|
/// <param name="entity">实体数据</param>
|
/// <param name="insertColumns">插入的列</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<int> InsertAsync(T entity, Expression<Func<T, object>> insertColumns, bool isRemoveDataCache = false)
|
{
|
var insert = DbBaseClient.Insertable(entity);
|
return isRemoveDataCache
|
? insertColumns == null
|
? await insert.RemoveDataCache().ExecuteReturnIdentityAsync()
|
: await insert.InsertColumns(insertColumns).RemoveDataCache().ExecuteReturnIdentityAsync()
|
: insertColumns == null
|
? await insert.ExecuteReturnIdentityAsync()
|
: await insert.InsertColumns(insertColumns).ExecuteReturnIdentityAsync();
|
}
|
|
/// <summary>
|
/// 写入实体数据
|
/// </summary>
|
/// <param name="entity">实体类</param>
|
/// <param name="insertColumns">需插入的字段</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool InsertGuid(T entity, Expression<Func<T, object>> insertColumns, bool isRemoveDataCache = false)
|
{
|
var insert = DbBaseClient.Insertable(entity);
|
return isRemoveDataCache
|
? insertColumns == null
|
? insert.RemoveDataCache().ExecuteCommand() > 0
|
: insert.InsertColumns(insertColumns).RemoveDataCache().ExecuteCommand() > 0
|
: insertColumns == null
|
? insert.ExecuteCommand() > 0
|
: insert.InsertColumns(insertColumns).ExecuteCommand() > 0;
|
}
|
|
/// <summary>
|
/// 写入实体数据
|
/// </summary>
|
/// <param name="entity">实体类</param>
|
/// <param name="insertColumns">需插入的字段</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> InsertGuidAsync(T entity, Expression<Func<T, object>> insertColumns, bool isRemoveDataCache = false)
|
{
|
var insert = DbBaseClient.Insertable(entity);
|
return isRemoveDataCache
|
? insertColumns == null
|
? await insert.RemoveDataCache().ExecuteCommandAsync() > 0
|
: await insert.InsertColumns(insertColumns).RemoveDataCache().ExecuteCommandAsync() > 0
|
: insertColumns == null
|
? await insert.ExecuteCommandAsync() > 0
|
: await insert.InsertColumns(insertColumns).ExecuteCommandAsync() > 0;
|
}
|
|
/// <summary>
|
/// 批量写入实体数据
|
/// </summary>
|
/// <param name="entity">实体类</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public int Insert(List<T> entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Insertable(entity.ToArray()).RemoveDataCache().ExecuteReturnIdentity() : DbBaseClient.Insertable(entity.ToArray()).ExecuteReturnIdentity();
|
}
|
|
/// <summary>
|
/// 批量写入实体数据
|
/// </summary>
|
/// <param name="entity">实体类</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<int> InsertAsync(List<T> entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Insertable(entity.ToArray()).RemoveDataCache().ExecuteCommandAsync()
|
: await DbBaseClient.Insertable(entity.ToArray()).ExecuteCommandAsync();
|
}
|
|
/// <summary>
|
/// 批量写入实体数据
|
/// </summary>
|
/// <param name="entity">实体类</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<int> InsertCommandAsync(List<T> entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Insertable(entity.ToArray()).RemoveDataCache().ExecuteCommandAsync()
|
: await DbBaseClient.Insertable(entity.ToArray()).ExecuteCommandAsync();
|
}
|
#endregion
|
|
#region 更新数据
|
|
/// <summary>
|
/// 批量更新实体数据
|
/// </summary>
|
/// <param name="entity">实体数据</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool Update(List<T> entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Updateable(entity).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Updateable(entity).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 批量更新实体数据
|
/// </summary>
|
/// <param name="entity">实体数据</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> UpdateAsync(List<T> entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Updateable(entity).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Updateable(entity).ExecuteCommandHasChangeAsync();
|
}
|
|
/// <summary>
|
/// 更新实体数据
|
/// </summary>
|
/// <param name="entity">实体数据</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool Update(T entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Updateable(entity).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Updateable(entity).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 更新实体数据
|
/// </summary>
|
/// <param name="entity">实体数据</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> UpdateAsync(T entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Updateable(entity).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Updateable(entity).ExecuteCommandHasChangeAsync();
|
}
|
|
/// <summary>
|
/// 更新某个字段
|
/// </summary>
|
/// <param name="columns">lambda表达式,如it => new Student() { Name = "a", CreateTime = DateTime.Now }</param>
|
/// <param name="where">lambda判断</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool Update(Expression<Func<T, T>> columns, Expression<Func<T, bool>> where, bool isRemoveDataCache = false)
|
{
|
var i = isRemoveDataCache ? DbBaseClient.Updateable<T>().SetColumns(columns).Where(where).RemoveDataCache().ExecuteCommand() : DbBaseClient.Updateable<T>().SetColumns(columns).Where(where).ExecuteCommand();
|
return i > 0;
|
}
|
|
/// <summary>
|
/// 更新某个字段
|
/// </summary>
|
/// <param name="columns">lambda表达式,如it => new Student() { Name = "a", CreateTime = DateTime.Now }</param>
|
/// <param name="where">lambda判断</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> UpdateAsync(Expression<Func<T, T>> columns, Expression<Func<T, bool>> where, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Updateable<T>().SetColumns(columns).Where(where).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Updateable<T>().SetColumns(columns).Where(where).ExecuteCommandHasChangeAsync();
|
}
|
|
#endregion
|
|
#region 删除数据
|
|
/// <summary>
|
/// 删除数据
|
/// </summary>
|
/// <param name="entity">实体类</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool Delete(T entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Deleteable(entity).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Deleteable(entity).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 删除数据
|
/// </summary>
|
/// <param name="entity">实体类</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteAsync(T entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Deleteable(entity).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Deleteable(entity).ExecuteCommandHasChangeAsync();
|
}
|
|
/// <summary>
|
/// 删除数据
|
/// </summary>
|
/// <param name="entity">实体类</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool Delete(IEnumerable<T> entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Deleteable<T>(entity).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Deleteable<T>(entity).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 删除数据
|
/// </summary>
|
/// <param name="entity">实体类</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteAsync(IEnumerable<T> entity, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Deleteable<T>(entity).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Deleteable<T>(entity).ExecuteCommandHasChangeAsync();
|
}
|
|
/// <summary>
|
/// 删除数据
|
/// </summary>
|
/// <param name="where">过滤条件</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool Delete(Expression<Func<T, bool>> where, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Deleteable(where).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Deleteable(where).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 删除数据
|
/// </summary>
|
/// <param name="where">过滤条件</param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteAsync(Expression<Func<T, bool>> where, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Deleteable(where).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Deleteable(where).ExecuteCommandHasChangeAsync();
|
}
|
|
/// <summary>
|
/// 删除指定ID的数据
|
/// </summary>
|
/// <param name="id"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool DeleteById(object id, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Deleteable<T>(id).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Deleteable<T>(id).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 删除指定ID的数据
|
/// </summary>
|
/// <param name="id"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteByIdAsync(object id, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Deleteable<T>(id).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Deleteable<T>(id).ExecuteCommandHasChangeAsync();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool DeleteByIds(int[] ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteByIdsAsync(int[] ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChangeAsync();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool DeleteByIds(long[] ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteByIdsAsync(long[] ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChangeAsync();
|
}
|
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool DeleteByIds(Guid[] ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteByIdsAsync(Guid[] ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChangeAsync();
|
}
|
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool DeleteByIds(string[] ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteByIdsAsync(string[] ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChangeAsync();
|
}
|
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool DeleteByIds(List<int> ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteByIdsAsync(List<int> ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChangeAsync();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool DeleteByIds(List<string> ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteByIdsAsync(List<string> ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChangeAsync();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool DeleteByIds(List<Guid> ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteByIdsAsync(List<Guid> ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChangeAsync();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public bool DeleteByIds(List<long> ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache ? DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChange() : DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChange();
|
}
|
|
/// <summary>
|
/// 删除指定ID集合的数据(批量删除)
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="isRemoveDataCache">是否清除缓存</param>
|
/// <returns></returns>
|
public async Task<bool> DeleteByIdsAsync(List<long> ids, bool isRemoveDataCache = false)
|
{
|
return isRemoveDataCache
|
? await DbBaseClient.Deleteable<T>().In(ids).RemoveDataCache().ExecuteCommandHasChangeAsync()
|
: await DbBaseClient.Deleteable<T>().In(ids).ExecuteCommandHasChangeAsync();
|
}
|
|
#endregion
|
|
#region 判断数据
|
/// <summary>
|
/// 判断数据是否存在
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <returns></returns>
|
public bool Exists(Expression<Func<T, bool>> predicate, bool blUseNoLock = false)
|
{
|
return DbBaseClient.Queryable<T>().Where(predicate).WithNoLockOrNot(blUseNoLock).Any();
|
}
|
|
/// <summary>
|
/// 判断数据是否存在
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <returns></returns>
|
public async Task<bool> ExistsAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false)
|
{
|
return await DbBaseClient.Queryable<T>().Where(predicate).WithNoLockOrNot(blUseNoLock).AnyAsync();
|
}
|
|
#endregion
|
|
#region 统计数据
|
|
/// <summary>
|
/// 获取数据总数
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public int GetCount(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return blUseNoLock
|
? DbBaseClient.Queryable<T>().WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).Count(predicate)
|
: DbBaseClient.Queryable<T>().WithCacheIF(isDataCache, cacheTimes).Count(predicate);
|
}
|
|
/// <summary>
|
/// 获取数据总数
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public async Task<int> GetCountAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return blUseNoLock
|
? await DbBaseClient.Queryable<T>().WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).CountAsync(predicate)
|
: await DbBaseClient.Queryable<T>().WithCacheIF(isDataCache, cacheTimes).CountAsync(predicate);
|
}
|
|
/// <summary>
|
/// 获取数据某个字段的合计
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="field">字段</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public int GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return blUseNoLock
|
? DbBaseClient.Queryable<T>().Where(predicate).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).Sum(field)
|
: DbBaseClient.Queryable<T>().Where(predicate).WithCacheIF(isDataCache, cacheTimes).Sum(field);
|
}
|
|
/// <summary>
|
/// 获取数据某个字段的合计
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="field">字段</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public async Task<int> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field,
|
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return blUseNoLock
|
? await DbBaseClient.Queryable<T>().Where(predicate).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).SumAsync(field)
|
: await DbBaseClient.Queryable<T>().Where(predicate).WithCacheIF(isDataCache, cacheTimes).SumAsync(field);
|
}
|
|
/// <summary>
|
/// 获取数据某个字段的合计
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="field">字段</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public decimal GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field,
|
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return blUseNoLock
|
? DbBaseClient.Queryable<T>().Where(predicate).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).Sum(field)
|
: DbBaseClient.Queryable<T>().Where(predicate).WithCacheIF(isDataCache, cacheTimes).Sum(field);
|
}
|
|
/// <summary>
|
/// 获取数据某个字段的合计
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="field">字段</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public async Task<decimal> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field,
|
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return blUseNoLock
|
? await DbBaseClient.Queryable<T>().Where(predicate).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).SumAsync(field)
|
: await DbBaseClient.Queryable<T>().Where(predicate).WithCacheIF(isDataCache, cacheTimes).SumAsync(field);
|
}
|
|
/// <summary>
|
/// 获取数据某个字段的合计
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="field">字段</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public float GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field,
|
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return blUseNoLock
|
? DbBaseClient.Queryable<T>().Where(predicate).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).Sum(field)
|
: DbBaseClient.Queryable<T>().Where(predicate).WithCacheIF(isDataCache, cacheTimes).Sum(field);
|
}
|
|
/// <summary>
|
/// 获取数据某个字段的合计
|
/// </summary>
|
/// <param name="predicate">条件表达式树</param>
|
/// <param name="field">字段</param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public async Task<float> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field,
|
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
return blUseNoLock
|
? await DbBaseClient.Queryable<T>().Where(predicate).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).SumAsync(field)
|
: await DbBaseClient.Queryable<T>().Where(predicate).WithCacheIF(isDataCache, cacheTimes).SumAsync(field);
|
}
|
#endregion
|
|
#region 分页数据
|
|
/// <summary>
|
/// 根据条件查询分页数据
|
/// </summary>
|
/// <param name="predicate">判断集合</param>
|
/// <param name="orderByType">排序方式</param>
|
/// <param name="pageIndex">当前页面索引</param>
|
/// <param name="pageSize">分布大小</param>
|
/// <param name="orderByExpression"></param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public IPageList<T> QueryPage(Expression<Func<T, bool>> predicate,
|
Expression<Func<T, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1,
|
int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
var totalCount = 0;
|
var page = blUseNoLock
|
? DbBaseClient.Queryable<T>().
|
OrderByIF(orderByExpression != null, orderByExpression, orderByType)
|
.WhereIF(predicate != null, predicate)
|
.WithNoLockOrNot(blUseNoLock)
|
.WithCacheIF(isDataCache, cacheTimes)
|
.ToPageList(pageIndex, pageSize, ref totalCount)
|
: DbBaseClient.Queryable<T>().
|
OrderByIF(orderByExpression != null, orderByExpression, orderByType)
|
.WhereIF(predicate != null, predicate)
|
.WithCacheIF(isDataCache, cacheTimes)
|
.ToPageList(pageIndex, pageSize, ref totalCount);
|
var list = new PageList<T>(page, pageIndex, pageSize, totalCount);
|
return list;
|
}
|
|
/// <summary>
|
/// 根据条件查询分页数据
|
/// </summary>
|
/// <param name="predicate">判断集合</param>
|
/// <param name="orderByType">排序方式</param>
|
/// <param name="pageIndex">当前页面索引</param>
|
/// <param name="pageSize">分布大小</param>
|
/// <param name="orderByExpression"></param>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public async Task<IPageList<T>> QueryPageAsync(Expression<Func<T, bool>> predicate,
|
Expression<Func<T, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1,
|
int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
RefAsync<int> totalCount = 0;
|
var page = blUseNoLock
|
? await DbBaseClient.Queryable<T>()
|
.WhereIF(predicate != null, predicate)
|
.OrderByIF(orderByExpression != null, orderByExpression, orderByType)
|
.WithNoLockOrNot(blUseNoLock)
|
.WithCacheIF(isDataCache, cacheTimes)
|
.ToPageListAsync(pageIndex, pageSize, totalCount)
|
: await DbBaseClient.Queryable<T>()
|
.WhereIF(predicate != null, predicate)
|
.OrderByIF(orderByExpression != null, orderByExpression, orderByType)
|
.WithCacheIF(isDataCache, cacheTimes)
|
.ToPageListAsync(pageIndex, pageSize, totalCount);
|
var list = new PageList<T>(page, pageIndex, pageSize, totalCount);
|
return list;
|
}
|
#endregion
|
|
#region 联表查询
|
|
/// <summary>
|
/// 查询-2表查询
|
/// </summary>
|
/// <typeparam name="T1">实体1</typeparam>
|
/// <typeparam name="T2">实体2</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>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns>值</returns>
|
public List<TResult> QueryMuch<T1, T2, TResult>(
|
Expression<Func<T1, T2, object[]>> joinExpression,
|
Expression<Func<T1, T2, TResult>> selectExpression,
|
Expression<Func<T1, T2, bool>> whereLambda = null,
|
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue) where T1 : class, new()
|
{
|
if (whereLambda == null)
|
return blUseNoLock
|
? DbBaseClient.Queryable(joinExpression).Select(selectExpression).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToList()
|
: DbBaseClient.Queryable(joinExpression).Select(selectExpression).WithCacheIF(isDataCache, cacheTimes).ToList();
|
return blUseNoLock
|
? DbBaseClient.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToList()
|
: DbBaseClient.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).WithCacheIF(isDataCache, cacheTimes).ToList();
|
}
|
|
/// <summary>
|
/// 查询-多表查询
|
/// </summary>
|
/// <typeparam name="T1">实体1</typeparam>
|
/// <typeparam name="T2">实体2</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>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns>值</returns>
|
public async Task<List<TResult>> QueryMuchAsync<T1, T2, TResult>(
|
Expression<Func<T1, T2, object[]>> joinExpression,
|
Expression<Func<T1, T2, TResult>> selectExpression,
|
Expression<Func<T1, T2, bool>> whereLambda = null,
|
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue) where T1 : class, new()
|
{
|
if (whereLambda == null)
|
return blUseNoLock
|
? await DbBaseClient.Queryable(joinExpression).Select(selectExpression).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToListAsync()
|
: await DbBaseClient.Queryable(joinExpression).Select(selectExpression).WithCacheIF(isDataCache, cacheTimes).ToListAsync();
|
return blUseNoLock
|
? await DbBaseClient.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToListAsync()
|
: await DbBaseClient.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).WithCacheIF(isDataCache, cacheTimes).ToListAsync();
|
}
|
|
/// <summary>
|
/// 查询-二表查询
|
/// </summary>
|
/// <typeparam name="T1">实体1</typeparam>
|
/// <typeparam name="T2">实体2</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>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns>值</returns>
|
public TResult QueryMuchFirst<T1, T2, TResult>(
|
Expression<Func<T1, T2, object[]>> joinExpression,
|
Expression<Func<T1, T2, TResult>> selectExpression,
|
Expression<Func<T1, T2, bool>> whereLambda = null,
|
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue) where T1 : class, new()
|
{
|
if (whereLambda == null)
|
return blUseNoLock
|
? DbBaseClient.Queryable(joinExpression).Select(selectExpression).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).First()
|
: DbBaseClient.Queryable(joinExpression).Select(selectExpression).WithCacheIF(isDataCache, cacheTimes).First();
|
return blUseNoLock
|
? DbBaseClient.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).First()
|
: DbBaseClient.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).WithCacheIF(isDataCache, cacheTimes).First();
|
}
|
|
/// <summary>
|
/// 查询-二表查询
|
/// </summary>
|
/// <typeparam name="T1">实体1</typeparam>
|
/// <typeparam name="T2">实体2</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>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns>值</returns>
|
public async Task<TResult> QueryMuchFirstAsync<T1, T2, TResult>(
|
Expression<Func<T1, T2, object[]>> joinExpression,
|
Expression<Func<T1, T2, TResult>> selectExpression,
|
Expression<Func<T1, T2, bool>> whereLambda = null,
|
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue) where T1 : class, new()
|
{
|
if (whereLambda == null)
|
return blUseNoLock
|
? await DbBaseClient.Queryable(joinExpression).Select(selectExpression).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).FirstAsync()
|
: await DbBaseClient.Queryable(joinExpression).Select(selectExpression).WithCacheIF(isDataCache, cacheTimes).FirstAsync();
|
return blUseNoLock
|
? await DbBaseClient.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).FirstAsync()
|
: await DbBaseClient.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).WithCacheIF(isDataCache, cacheTimes).FirstAsync();
|
}
|
|
/// <summary>
|
/// 查询-三表查询
|
/// </summary>
|
/// <typeparam name="T1"></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>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns>值</returns>
|
public List<TResult> QueryMuch<T1, T2, T3, TResult>(
|
Expression<Func<T1, T2, T3, object[]>> joinExpression,
|
Expression<Func<T1, T2, T3, TResult>> selectExpression,
|
Expression<Func<T1, T2, T3, bool>> whereLambda = null,
|
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue) where T1 : class, new()
|
{
|
if (whereLambda == null)
|
return blUseNoLock
|
? DbBaseClient.Queryable(joinExpression).Select(selectExpression).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToList()
|
: DbBaseClient.Queryable(joinExpression).Select(selectExpression).WithCacheIF(isDataCache, cacheTimes).ToList();
|
return blUseNoLock
|
? DbBaseClient.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToList()
|
: DbBaseClient.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).WithCacheIF(isDataCache, cacheTimes).ToList();
|
}
|
|
/// <summary>
|
/// 查询-三表查询
|
/// </summary>
|
/// <typeparam name="T1"></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>
|
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns>值</returns>
|
public async Task<List<TResult>> QueryMuchAsync<T1, T2, T3, TResult>(
|
Expression<Func<T1, T2, T3, object[]>> joinExpression,
|
Expression<Func<T1, T2, T3, TResult>> selectExpression,
|
Expression<Func<T1, T2, T3, bool>> whereLambda = null,
|
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue) where T1 : class, new()
|
{
|
if (whereLambda == null)
|
return blUseNoLock
|
? await DbBaseClient.Queryable(joinExpression).Select(selectExpression).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToListAsync()
|
: await DbBaseClient.Queryable(joinExpression).Select(selectExpression).WithCacheIF(isDataCache, cacheTimes).ToListAsync();
|
return blUseNoLock
|
? await DbBaseClient.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).WithNoLockOrNot(blUseNoLock).WithCacheIF(isDataCache, cacheTimes).ToListAsync()
|
: await DbBaseClient.Queryable(joinExpression).Where(whereLambda).Select(selectExpression).WithCacheIF(isDataCache, cacheTimes).ToListAsync();
|
}
|
#endregion
|
|
#region Sql操作
|
|
/// <summary>
|
/// 执行sql语句并返回List<T />
|
/// </summary>
|
/// <typeparam name="T"></typeparam>
|
/// <param name="sql"></param>
|
/// <param name="parameters"></param>
|
/// <returns></returns>
|
public List<T> SqlQuery(string sql, List<SugarParameter> parameters)
|
{
|
var list = DbBaseClient.Ado.SqlQuery<T>(sql, parameters);
|
return list;
|
}
|
|
/// <summary>
|
/// 执行sql语句并返回List<T />
|
/// </summary>
|
/// <typeparam name="T"></typeparam>
|
/// <param name="sql"></param>
|
/// <param name="isDataCache">是否启用缓存</param>
|
/// <param name="cacheTimes">缓存时长（分钟）</param>
|
/// <returns></returns>
|
public async Task<List<T>> SqlQueryable(string sql, bool isDataCache = false, int cacheTimes = int.MaxValue)
|
{
|
var list = await DbBaseClient.SqlQueryable<T>(sql).WithCacheIF(isDataCache, cacheTimes).ToListAsync();
|
return list;
|
}
|
|
|
/// <summary>
|
/// 执行调用存储过程（返回DataTable）
|
/// </summary>
|
/// <param name="useStoredProcedureName">存储过程名称</param>
|
/// <param name="parameters">参数</param>
|
/// <returns></returns>
|
public async Task<DataTable> SqlQueryDataTableByStoredProcedure(string useStoredProcedureName, List<SugarParameter> parameters)
|
{
|
var list = await DbBaseClient.Ado.UseStoredProcedure().GetDataTableAsync(useStoredProcedureName, parameters);//返回DataTable
|
return list;
|
}
|
|
|
/// <summary>
|
/// 执行调用存储过程（返回List<T>）
|
/// </summary>
|
/// <typeparam name="T">返回类型</typeparam>
|
/// <param name="useStoredProcedureName">存储过程名称</param>
|
/// <param name="parameters">参数</param>
|
/// <returns></returns>
|
public async Task<List<T>> SqlQueryableByStoredProcedure(string useStoredProcedureName, List<SugarParameter> parameters)
|
{
|
var list = await DbBaseClient.Ado.UseStoredProcedure().SqlQueryAsync<T>(useStoredProcedureName, parameters);//返回List
|
return list;
|
}
|
#endregion
|
|
}
|
}
|
