wgh/coreshoppro
1
0
Fork 0
mirror of http://git.coreshop.cn/jianweie/coreshoppro.git synced 2025-12-06 17:33:27 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
090b503f8de661cb353326b245bdfe8d15503540
coreshoppro/CoreCms.Net.IServices/IBaseServices.cs

1003 lines
48 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/***********************************************************************
* 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.Model.ViewModels.Basics;
using SqlSugar;
namespace CoreCms.Net.IServices
{
/// <summary>
/// 服务仓储通用接口类
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IBaseServices<T> where T : class
{
#region 查询数据
/// <summary>
/// 根据主值查询单条数据
/// </summary>
/// <param name="pkValue">主键值</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns>泛型实体</returns>
T QueryById(object pkValue, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据主值查询单条数据
/// </summary>
/// <param name="objId"></param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
Task<T> QueryByIdAsync(object objId, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据主值列表查询单条数据
/// </summary>
/// <param name="lstIds"></param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
List<T> QueryByIDs(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据主值列表查询单条数据
/// </summary>
/// <param name="lstIds"></param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
Task<List<T>> QueryByIDsAsync(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据主值列表查询单条数据
/// </summary>
/// <param name="lstIds"></param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
List<T> QueryByIDs(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据主值列表查询单条数据
/// </summary>
/// <param name="lstIds"></param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
Task<List<T>> QueryByIDsAsync(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 查询所有数据(无分页,请慎用)
/// </summary>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
List<T> Query(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 查询所有数据(无分页,请慎用)
/// </summary>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
Task<List<T>> QueryAsync(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="strWhere">条件</param>
/// <param name="orderBy">排序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns>泛型实体集合</returns>
List<T> QueryListByClause(string strWhere, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="strWhere">条件</param>
/// <param name="orderBy">排序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns>泛型实体集合</returns>
Task<List<T>> QueryListByClauseAsync(string strWhere, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="orderBy">排序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns>泛型实体集合</returns>
List<T> QueryListByClause(Expression<Func<T, bool>> predicate, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="orderBy">排序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns>泛型实体集合</returns>
Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, string orderBy = "",
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <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>
List<T> QueryListByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate,
OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <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>
Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate,
Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <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>
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);
/// <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>
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);
/// <summary>
/// 根据条件查询一定数量数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="take">获取数量</param>
/// <param name="strOrderByFields">排序字段，如name asc,age desc</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
List<T> QueryListByClause(Expression<Func<T, bool>> predicate, int take, string strOrderByFields = "",
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询一定数量数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="take">获取数量</param>
/// <param name="strOrderByFields">排序字段，如name asc,age desc</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, int take,
string strOrderByFields = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
T QueryByClause(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <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>
T QueryByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate,
OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <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>
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);
/// <summary>
/// 根据条件查询数据（悲观锁等待模式）
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="orderByPredicate">排序字段</param>
/// <param name="orderByType">排序顺序</param>
/// <param name="blUseTranLock">是否使用TranLock</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
Task<T> QueryByClauseWithTranLockAsync(Expression<Func<T, bool>> predicate,
Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseTranLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
#endregion
#region 新闻数据
/// <summary>
/// 写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
int Insert(T entity, bool isRemoveDataCache = false);
/// <summary>
/// 写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<int> InsertAsync(T entity, bool isRemoveDataCache = false);
/// <summary>
/// 写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="insertColumns"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
int Insert(T entity, Expression<Func<T, object>> insertColumns, bool isRemoveDataCache = false);
/// <summary>
/// 写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="insertColumns"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<int> InsertAsync(T entity, Expression<Func<T, object>> insertColumns, bool isRemoveDataCache = false);
/// <summary>
/// 写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="insertColumns"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool InsertGuid(T entity, Expression<Func<T, object>> insertColumns, bool isRemoveDataCache = false);
/// <summary>
/// 写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="insertColumns"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> InsertGuidAsync(T entity, Expression<Func<T, object>> insertColumns, bool isRemoveDataCache = false);
/// <summary>
/// 批量写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
int Insert(List<T> entity, bool isRemoveDataCache = false);
/// <summary>
/// 批量写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<int> InsertAsync(List<T> entity, bool isRemoveDataCache = false);
/// <summary>
/// 批量写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<int> InsertCommandAsync(List<T> entity, bool isRemoveDataCache = false);
#endregion
#region 更新数据
/// <summary>
/// 批量更新实体数据
/// </summary>
/// <param name="entity"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Update(List<T> entity, bool isRemoveDataCache = false);
/// <summary>
/// 批量更新实体数据
/// </summary>
/// <param name="entity"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> UpdateAsync(List<T> entity, bool isRemoveDataCache = false);
/// <summary>
/// 更新实体数据
/// </summary>
/// <param name="entity"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Update(T entity, bool isRemoveDataCache = false);
/// <summary>
/// 更新实体数据
/// </summary>
/// <param name="entity"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> UpdateAsync(T entity, bool isRemoveDataCache = false);
/// <summary>
/// 根据手写条件更新
/// </summary>
/// <param name="entity"></param>
/// <param name="strWhere"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Update(T entity, string strWhere, bool isRemoveDataCache = false);
/// <summary>
/// 根据手写条件更新
/// </summary>
/// <param name="entity"></param>
/// <param name="strWhere"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> UpdateAsync(T entity, string strWhere, bool isRemoveDataCache = false);
/// <summary>
/// 根据手写sql语句更新数据
/// </summary>
/// <param name="strSql"></param>
/// <param name="parameters"></param>
/// <returns></returns>
bool Update(string strSql, SugarParameter[] parameters = null);
/// <summary>
/// 根据手写sql语句更新数据
/// </summary>
/// <param name="strSql"></param>
/// <param name="parameters"></param>
/// <returns></returns>
Task<bool> UpdateAsync(string strSql, SugarParameter[] parameters = null);
/// <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>
bool Update(Expression<Func<T, T>> columns, Expression<Func<T, bool>> where, bool isRemoveDataCache = false);
/// <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>
Task<bool> UpdateAsync(Expression<Func<T, T>> columns, Expression<Func<T, bool>> where, bool isRemoveDataCache = false);
/// <summary>
/// 根据条件更新
/// </summary>
/// <param name="entity"></param>
/// <param name="lstColumns"></param>
/// <param name="lstIgnoreColumns"></param>
/// <param name="strWhere"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> UpdateAsync(T entity, List<string> lstColumns, List<string> lstIgnoreColumns,
string strWhere = "", bool isRemoveDataCache = false);
/// <summary>
/// 根据条件更新
/// </summary>
/// <param name="entity"></param>
/// <param name="lstColumns"></param>
/// <param name="lstIgnoreColumns"></param>
/// <param name="strWhere"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Update(T entity, List<string> lstColumns, List<string> lstIgnoreColumns, string strWhere = "", bool isRemoveDataCache = false);
#endregion
#region 删除数据
/// <summary>
/// 删除数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Delete(T entity, bool isRemoveDataCache = false);
/// <summary>
/// 删除数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteAsync(T entity, bool isRemoveDataCache = false);
/// <summary>
/// 删除数据
/// </summary>
/// <param name="entity">实体类集合</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Delete(IEnumerable<T> entity, bool isRemoveDataCache = false);
/// <summary>
/// 删除数据
/// </summary>
/// <param name="entity">实体类集合</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteAsync(IEnumerable<T> entity, bool isRemoveDataCache = false);
/// <summary>
/// 删除数据
/// </summary>
/// <param name="where">过滤条件</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Delete(Expression<Func<T, bool>> where, bool isRemoveDataCache = false);
/// <summary>
/// 删除数据
/// </summary>
/// <param name="where">过滤条件</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteAsync(Expression<Func<T, bool>> where, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID的数据
/// </summary>
/// <param name="id"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteById(object id, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID的数据
/// </summary>
/// <param name="id"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdAsync(object id, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(int[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(int[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(long[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(long[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(Guid[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(Guid[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(string[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(string[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(List<int> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(List<int> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(List<string> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(List<string> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(List<Guid> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(List<Guid> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(List<long> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(List<long> ids, bool isRemoveDataCache = false);
#endregion
#region 判断数据
/// <summary>
/// 判断数据是否存在
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <returns></returns>
bool Exists(Expression<Func<T, bool>> predicate, bool blUseNoLock = false);
/// <summary>
/// 判断数据是否存在
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <returns></returns>
Task<bool> ExistsAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false);
#endregion
#region 统计数据
/// <summary>
/// 获取数据总数
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
int GetCount(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 获取数据总数
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
Task<int> GetCountAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <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>
int GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <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>
Task<int> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <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>
decimal GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <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>
Task<decimal> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <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>
float GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <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>
Task<float> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
#endregion
#region 分页查询
/// <summary>
/// 根据条件查询分页数据
/// </summary>
/// <param name="predicate"></param>
/// <param name="orderBy"></param>
/// <param name="pageIndex">当前页面索引</param>
/// <param name="pageSize">分布大小</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
IPageList<T> QueryPage(Expression<Func<T, bool>> predicate, string orderBy = "", int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询分页数据
/// </summary>
/// <param name="predicate"></param>
/// <param name="orderBy"></param>
/// <param name="pageIndex">当前页面索引</param>
/// <param name="pageSize">分布大小</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
Task<IPageList<T>> QueryPageAsync(Expression<Func<T, bool>> predicate, string orderBy = "", int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <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>
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);
/// <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>
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);
#endregion
#region 联表查询
/// <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>
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();
/// <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>
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();
/// <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>
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();
/// <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>
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();
/// <summary>
/// 查询-三表查询
/// </summary>
/// <typeparam name="T2">实体2</typeparam>
/// <typeparam name="T3">实体3</typeparam>
/// <typeparam name="TResult">返回对象</typeparam>
/// <typeparam name="T1"></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>
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();
/// <summary>
/// 查询-三表查询
/// </summary>
/// <typeparam name="T2">实体2</typeparam>
/// <typeparam name="T3">实体3</typeparam>
/// <typeparam name="TResult">返回对象</typeparam>
/// <typeparam name="T1"></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>
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();
#endregion
#region SQL查询
/// <summary>
/// 执行sql语句并返回List<T />
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="parameters"></param>
/// <returns></returns>
List<T> SqlQuery(string sql, List<SugarParameter> parameters);
/// <summary>
/// 执行sql语句并返回List<T />
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（分钟）</param>
/// <returns></returns>
Task<List<T>> SqlQueryable(string sql, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 执行调用存储过程（返回DataTable）
/// </summary>
/// <param name="useStoredProcedureName">存储过程名称</param>
/// <param name="parameters">参数</param>
/// <returns></returns>
Task<DataTable> SqlQueryDataTableByStoredProcedure(string useStoredProcedureName, List<SugarParameter> parameters);
/// <summary>
/// 执行调用存储过程（返回List<T>）
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="useStoredProcedureName">存储过程名称</param>
/// <param name="parameters">参数</param>
/// <returns></returns>
Task<List<T>> SqlQueryableByStoredProcedure(string useStoredProcedureName, List<SugarParameter> parameters);
#endregion
}
}
Reference in New Issue View Git Blame Copy Permalink