public EfBaseRepository(
IDbContextProvider <TDbContext> dbContextProvider,
IPredicateGroup <TEntity> predicateGroup)
{
_dbContextProvider = dbContextProvider;
PredicateGroup = predicateGroup;
}
/// <summary>
/// 获取已分页的实体列表
/// </summary>
/// <param name="predicate">谓语（条件）</param>
/// <param name="sort">排序列表</param>
/// <param name="page"></param>
/// <param name="resultsPerPage"></param>
/// <returns></returns>
public virtual IEnumerable <T> GetPage(IPredicateGroup predicate, IList <ISort> sort, int page, int resultsPerPage)
{
using (var db = DbContext.CreateInstance())
{
return(db.GetPage <T>(predicate, sort, page, resultsPerPage));
}
}
/// <summary>
/// DapperExtensions 没有实现一对多
/// // 多表联查在这个库里没有提供，多表联查的话可以自己用Dapper的Query<T>(TFirst, TSecond, TResult,...)这个方法来实现
/// </summary>
/// <returns></returns>
public IEnumerable <TestPersonEntity> TestDapperExtensions()
{
// Map 文件 TestPersonEntityMapper
SqlConnection connection = new SqlConnection(connectionString);
var config = new DapperExtensionsConfiguration(typeof(AutoClassMapper <>), new List <Assembly>(), new SqlServerDialect());
// new List<Assembly>() --> Count =0
var sqlGenerator = new SqlGeneratorImpl(config);
Db = new Database(connection, sqlGenerator);
// 拼接条件 查询
IList <IPredicate> predList = new List <IPredicate>();
predList.Add(Predicates.Field <TestEntity>(p => p.Name, Operator.Like, "A%"));
predList.Add(Predicates.Field <TestEntity>(p => p.Id, Operator.Eq, 2));
IPredicateGroup predGroup = Predicates.Group(GroupOperator.And, predList.ToArray());
var ret1 = Db.GetList <TestEntity>(predGroup);
var ret2 = Db.GetList <TestPersonEntity>();
connection.Close();
return(ret2);
//TestEntity p2 = Db.Get<TestEntity>(1);
//return p2.Address;
}
/// <summary>
/// 分页查询用户信息
/// </summary>
/// <param name="queryUserInput"></param>
/// <returns></returns>
public async Task <PageOutput <QueryUserOutput> > GetPageUsers(PageInput <QueryUserInput> queryUserInput)
{
long rows;
IList <IPredicate> predlist = new List <IPredicate>();
predlist.Add(Predicates.Field <User>(p => p.Status, Operator.Eq, (int)Status.normal));
if (queryUserInput != null && queryUserInput.Query != null && !string.IsNullOrWhiteSpace(queryUserInput.Query.UserName))
{
predlist.Add(Predicates.Field <User>(p => p.UserName, Operator.Like, queryUserInput.Query.UserName + "%"));
}
IPredicateGroup group = Predicates.Group(GroupOperator.And, predlist.ToArray());
IList <ISort> sorts = new List <ISort>();
sorts.Add(new Sort {
PropertyName = "Id", Ascending = false
});
var users = Mapper.Map <IEnumerable <User>, IEnumerable <QueryUserOutput> >(await _userRepository.GetPage(group, sorts, queryUserInput.PageIndex, queryUserInput.PageSize, out rows));
return(new PageOutput <QueryUserOutput> {
Rows = rows, Result = users, PageIndex = queryUserInput.PageIndex
});
}
public virtual void AddTo(IPredicateGroup group)
{
if (group != null)
{
group.Add(this);
}
}
public IEnumerable <T> GetPage <T>(IDbConnection connection, IPredicateGroup predicate, IList <ISort> sort, int page,
int resultsPerPage, IDbTransaction transaction, int?commandTimeout, bool buffered) where T : class
{
var classMap = SqlGenerator.Configuration.GetMap <T>();
return(GetPage <T>(connection, classMap, predicate, sort, page, resultsPerPage, transaction,
commandTimeout, buffered));
}
/// <summary>
/// WhereIf
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbSet"></param>
/// <param name="predicateGroup"></param>
/// <returns></returns>
public static IQueryable <T> WhereIf <T>(this DbSet <T> dbSet, IPredicateGroup <T> predicateGroup)
where T : class
{
return(predicateGroup.Predicates
.Aggregate(dbSet.AsQueryable(),
(current, predicate) =>
predicate.Condition ? current.Where(predicate.Expression) : current));
}
private IEnumerable <T> ResolveEnities()
{
IPredicateGroup predicate = QueryBuilder <T> .FromExpression(_expression);
IPredicateGroup p = predicate?.Predicates == null ? null : predicate;
return(_session.GetList <T>(p, _sort, _session.Transaction, _timeout, false, _take, _nolock));
}
/// <summary>
/// WhereIf
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="predicateGroup"></param>
/// <returns></returns>
public static IQueryable <T> WhereIf <T>(this IQueryable <T> source, IPredicateGroup <T> predicateGroup)
where T : class
{
return(predicateGroup.Predicates
.Aggregate(source,
(current, predicate) =>
predicate.Condition ? current.Where(predicate.Expression) : current));
}
private IFieldPredicate GetCurrentField(IPredicateGroup group)
{
IPredicate last = group.Predicates.Last();
if (last is IPredicateGroup)
{
return(GetCurrentField(last as IPredicateGroup));
}
return(last as IFieldPredicate);
}
private async Task <IEnumerable <T> > ResolveEnitiesAsync()
{
IPredicateGroup predicate = QueryBuilder <T> .FromExpression(_expression);
if (_offset.HasValue && _take.HasValue)
{
return(await _dapperImplementor.GetListPagedAsync <T>(_session, predicate, _sort, _session.Transaction, _timeout, _offset.Value, _take.Value, _nolock));
}
return(await _dapperImplementor.GetListAsync <T>(_session, predicate, _sort, _session.Transaction, _timeout, _take, _nolock));
}
public ReferenceMap(PropertyInfo propertyInfo, Guid parentIdentity)
{
Name = propertyInfo.Name;
PropertyInfo = propertyInfo;
ReferenceProperties = new List <IReferenceProperty>();
Identity = Guid.NewGuid();
ParentIdentity = parentIdentity;
JoinType = JoinType.Left;
JoinPredicate = null;
}
private IEnumerable <T> ResolveEnities()
{
IPredicateGroup predicate = QueryBuilder <T> .FromExpression(_expression);
//IPredicateGroup p = predicate?.Predicates == null ? null : predicate;
if (_offset.HasValue && _take.HasValue)
{
return(_dapperImplementor.GetListPaged <T>(_session, predicate, _sort, _session.Transaction, _timeout, false, _offset.Value, _take.Value, _nolock));
}
return(_dapperImplementor.GetList <T>(_session, predicate, _sort, _session.Transaction, _timeout, false, _take, _nolock));
}
/// <summary>
/// DapperExtensions 用法
/// </summary>
public void DapperExtensions()
{
//实体类
UsersEntity entity = new UsersEntity();
IDbTransaction tran = this.DBSession.Begin();
int userId = this.Insert(entity, tran); //插入
int userId1 = this.Insert(entity, tran); //插入
tran.Commit();
bool isSuccess = this.Update(entity);//更新
int count = this.Delete(entity); //删除
entity = this.GetById(1); //获得实体
int count1 = this.Count(new { ID = 1 }); //数量
//查询所有
IEnumerable <UsersEntity> list = this.GetAll();
//条件查询
IList <ISort> sort = new List <ISort>();
sort.Add(new Sort {
PropertyName = "UserId", Ascending = false
});
IEnumerable <UsersEntity> list1 = this.GetList(new { UserId = 1, Name = "123" }, sort);
//orm 拼接条件 查询 繁琐 不灵活 不太好用
IList <IPredicate> predList = new List <IPredicate>();
predList.Add(Predicates.Field <UsersEntity>(p => p.LoginName, Operator.Like, "不知道%"));
predList.Add(Predicates.Field <UsersEntity>(p => p.UserId, Operator.Eq, 1));
IPredicateGroup predGroup = Predicates.Group(GroupOperator.And, predList.ToArray());
list = this.GetList(predGroup);
//分页查询
long allRowsCount = 0;
this.GetPageList(1, 10, out allRowsCount, new { ID = 1 }, sort);
}
/// <summary>
/// 根据条件获取表数据
/// </summary>
/// <param name="predicate">表达式</param>
/// <returns></returns>
public List <TEntity> GetList(IPredicateGroup predicate, object sortList = null)
{
using (var conn = ConnectionFactory.CreateMainSiteConnection())
{
IList <ISort> sort = null;
if (sortList != null)
{
sort = SortConvert(sortList);//转换排序接口
}
return(conn.GetList <TEntity>(predicate, sort, transaction: conn.BeginTransaction(IsolationLevel.ReadUncommitted)).ToList());
}
}
public IHttpActionResult Page(string query)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
Comm.RequestModel.RequestModelBase <Sys.Models.VenueNotice> oData = Newtonsoft.Json.JsonConvert.DeserializeObject <Comm.RequestModel.RequestModelBase <Sys.Models.VenueNotice> >(query);
if (oData.PageIndex < 0 || oData.PageSize <= 0 || oData.SearchCondition == null || oData.SearchCondition.VenueID <= 0)
{
return(BadRequest());
}
try
{
IList <IPredicate> predList = new List <IPredicate>();
predList.Add(Predicates.Field <Sys.Models.VenueNotice>(f => f.VenueID, Operator.Eq, oData.SearchCondition.VenueID));
if (oData.SearchCondition.State > -1)
{
predList.Add(Predicates.Field <Sys.Models.VenueNotice>(f => f.State, Operator.Eq, oData.SearchCondition.State));
}
IPredicateGroup predGroup = Predicates.Group(GroupOperator.And, predList.ToArray());
var result = Comm.Helper.DapperHelper.Instance.GetPage <Sys.Models.VenueNotice>(
predGroup,
new List <ISort>()
{
new Sort {
PropertyName = "NoticeId", Ascending = false
},
},
oData.PageIndex,
oData.PageSize
);
long allRowsCount = Comm.Helper.DapperHelper.Instance.Count <YY.Edu.Sys.Models.VenueNotice>(predGroup);
return(Ok(new Comm.ResponseModel.ResponseModel4Page <YY.Edu.Sys.Models.VenueNotice>()
{
data = result.AsList(),
recordsFiltered = allRowsCount,
recordsTotal = allRowsCount,
}));
}
catch (Exception ex)
{
logs.Error("公告分页查询失败", ex);
return(BadRequest());
}
}
private IEnumerable <T> ResolveEnities()
{
IPredicateGroup predicate = QueryBuilder <T> .FromExpression(_expression);
if (_pageIndex != null && _pageSize != null)
{
return(_session.GetDatabase().GetPage <T>(predicate ?? null, _sort, _pageIndex.GetValueOrDefault(), _pageSize.GetValueOrDefault(), _timeout, false));
}
else
{
return(_session.GetDatabase().GetList <T>(predicate ?? null, _sort, _session.GetTransaction(), _timeout, false));
}
}
private string GetSql(IPredicateGroup predicateGroup, IDictionary <string, object> parameters)
{
var separator = predicateGroup.Operator == GroupOperator.And ? " AND " : " OR ";
var predicateSqlStatements = predicateGroup.Predicates
.Select(predicate => _predicateQueryBuilderFactory.GetQueryBuilder(predicate, _sqlBuilder).GetSql(predicate, parameters))
.Where(sql => !string.IsNullOrEmpty(sql))
.ToArray();
return(predicateSqlStatements.Length == 0
? _sqlBuilder.Dialect.EmptyExpression
: $"({string.Join(separator, predicateSqlStatements)})");
}
public void MySQLBuildTest()
{
IDapperExtensionsConfiguration conf = new DapperExtensionsConfiguration(typeof(AutoClassMapper <>), new List <Assembly>(), new MySqlDialect());
SqlGeneratorImpl sqlGeneratorImpl = new SqlGeneratorImpl(conf);
IFieldPredicate nameFieldPredicate = Predicates.Field <User>(p => p.Name, Operator.Like, "уе%");
string namesql = nameFieldPredicate.GetSql(sqlGeneratorImpl, new Dictionary <string, object>());
Assert.Equal("(`User`.`Name` LIKE @Name_0)", namesql);
List <string> valueList = new List <string>()
{
"1", "2", "3"
};
IFieldPredicate nameFieldPredicate2 = Predicates.Field <User>(p => p.Name, Operator.Eq, valueList);
string namesql2 = nameFieldPredicate2.GetSql(sqlGeneratorImpl, new Dictionary <string, object>());
Assert.Equal("(`User`.`Name` IN (@Name_0, @Name_1, @Name_2))", namesql2);
IBetweenPredicate idFieldPredicate = Predicates.Between <User>(p => p.Name, new BetweenValues {
Value1 = 1, Value2 = 10
}, true);
string idsql = idFieldPredicate.GetSql(sqlGeneratorImpl, new Dictionary <string, object>());
Assert.Equal("(`User`.`Name` NOT BETWEEN @Name_0 AND @Name_1)", idsql);
IPropertyPredicate propertyPredicate = Predicates.Property <User, Role>(u => u.RoleId, Operator.Eq, r => r.Id, true);
string propertysql = propertyPredicate.GetSql(sqlGeneratorImpl, new Dictionary <string, object>());
Assert.Equal("(`User`.`RoleId` <> `Role`.`Id`)", propertysql);
IExistsPredicate existsPredicate = Predicates.Exists <User>(nameFieldPredicate, true);
string existssql = existsPredicate.GetSql(sqlGeneratorImpl, new Dictionary <string, object>());
Assert.Equal("(NOT EXISTS (SELECT 1 FROM `User` WHERE (`User`.`Name` LIKE @Name_0)))", existssql);
IList <IPredicate> predList = new List <IPredicate> {
nameFieldPredicate, idFieldPredicate
};
IPredicateGroup predGroup1 = Predicates.Group(GroupOperator.And, predList.ToArray());
IList <IPredicate> predList2 = new List <IPredicate> {
predGroup1, existsPredicate
};
IPredicateGroup predGroup2 = Predicates.Group(GroupOperator.Or, predList2.ToArray());
string groupsql = predGroup2.GetSql(sqlGeneratorImpl, new Dictionary <string, object>());
string res = "(((`User`.`Name` LIKE @Name_0) AND (`User`.`Name` NOT BETWEEN @Name_1 AND @Name_2)) OR (NOT EXISTS (SELECT 1 FROM `User` WHERE (`User`.`Name` LIKE @Name_3))))";
Assert.Equal(groupsql, res);
}
public Task <IList <PessoaEndereco> > Handle(GetEnderecosCompradorQuery request, CancellationToken cancellationToken)
{
using (var ctx = this.DbContextFactory.NewContext())
{
var repo = ctx.AcquireRepository <IPessoaEnderecoRepository>();
IPredicateGroup filtros = Predicates.Group(GroupOperator.And,
Predicates.Field <PessoaEndereco>(a => a.idpessoa, Operator.Eq, request.Pessoa.idpessoa)
);
var enderecos = repo.Fetch(filtros, cancellationToken).Result;
return(Task.FromResult <IList <PessoaEndereco> >(enderecos));
}
}
/// <summary>
/// 数据表 分页
/// </summary>
/// <param name="pageNum">指定页数 索引从0开始</param>
/// <param name="pageSize">指定每页多少项</param>
///<param name="outTotal">输出当前表的总项数</param>
/// <param name="expression">条件 linq表达式 谓词</param>
/// <param name="sortList">排序字段</param>
/// <returns></returns>
public List <TEntity> GetPageData(int pageNum, int pageSize, out long outTotal,
Expression <Func <TEntity, bool> > expression = null, object sortList = null)
{
using (var conn = ConnectionFactory.CreateMainSiteConnection())
{
IDbTransaction transaction = conn.BeginTransaction(IsolationLevel.ReadUncommitted);
int commandTimeout = 1800;
IPredicateGroup predicate = DapperLinqBuilder <TEntity> .FromExpression(expression); //转换Linq表达式
IList <ISort> sort = SortConvert(sortList); //转换排序接口
var entities = conn.GetPage <TEntity>(predicate, sort, pageNum, pageSize, transaction: conn.BeginTransaction(IsolationLevel.ReadUncommitted)).ToList();
outTotal = conn.Count <TEntity>(predicate, transaction, commandTimeout);
return(entities);
}
}
public Task <ProdutoDto> Handle(GetProdutoByIdQuery request, CancellationToken cancellationToken)
{
using (var ctx = this.DbContextFactory.NewContext())
{
var repo = ctx.AcquireRepository <IProdutoRepository>();
IPredicateGroup filtros = Predicates.Group(GroupOperator.And,
Predicates.Field <ProdutoDto>(a => a.idpropietario, Operator.Eq, request.User.Loja.Propietario)
, Predicates.Field <ProdutoDto>(a => a.idloja, Operator.Eq, request.User.Loja.Loja)
, Predicates.Field <ProdutoDto>(a => a.idproduto, Operator.Eq, request.Filters.idproduto)
);
var produtos = repo.FetchDto(filtros, cancellationToken).Result;
return(Task.FromResult <ProdutoDto>(produtos.First()));
}
}
/// <summary>
/// 数据表 分页
/// </summary>
/// <param name="pager">页数信息</param>
/// <param name="predicate">条件</param>
/// <param name="sortList">排序字段</param>
/// <returns></returns>
public List <TEntity> GetPageData(XPager pager, IPredicateGroup predicate = null, object sortList = null)
{
using (var conn = ConnectionFactory.CreateMainSiteConnection())
{
IDbTransaction transaction = conn.BeginTransaction(IsolationLevel.ReadUncommitted);
int commandTimeout = 1800;
IList <ISort> sort = null;
if (sortList != null)
{
sort = SortConvert(sortList);//转换排序接口
}
var entities = conn.GetPage <TEntity>(predicate, sort, pager.PageIndex, pager.PageSize, transaction).ToList();
pager.RecordCount = conn.Count <TEntity>(predicate, transaction, commandTimeout);
return(entities);
}
}
public Task <IEnumerable <Categoria> > Handle(GetCategoriasQuery request, CancellationToken cancellationToken)
{
using (var ctx = this.DbContextFactory.NewContext())
{
var repo = ctx.AcquireRepository <ICategoriaRepository>();
IPredicateGroup filtros = Predicates.Group(GroupOperator.And,
Predicates.Field <Produto>(a => a.idpropietario, Operator.Eq, request.User.Loja.Propietario)
, Predicates.Field <Produto>(a => a.idloja, Operator.Eq, request.User.Loja.Loja)
, Predicates.Field <Produto>(a => a.situacao, Operator.Eq, "A")
);
var categorias = repo.Fetch(filtros, cancellationToken).Result;
return(Task.FromResult <IEnumerable <Categoria> >(categorias));
}
}
/// <summary>
/// 数据表 分页
/// </summary>
/// <param name="pager">页数信息</param>
/// <param name="fields">要查询是字段对象</param>
/// <param name="expression">条件 linq表达式 谓词</param>
/// <param name="sortList">排序字段</param>
/// <returns></returns>
public List <TEntity> GetPageData(XPager pager, string[] fields, Expression <Func <TEntity, bool> > expression = null, object sortList = null)
{
using (var conn = ConnectionFactory.CreateMainSiteConnection())
{
IDbTransaction transaction = conn.BeginTransaction(IsolationLevel.ReadUncommitted);
int commandTimeout = 1800;
IPredicateGroup predicate = DapperLinqBuilder <TEntity> .FromExpression(expression); //转换Linq表达式
IList <ISort> sort = null;
if (sortList != null)
{
sort = SortConvert(sortList);//转换排序接口
}
var entities = conn.GetPage <TEntity>(fields, predicate, sort, pager.PageIndex, pager.PageSize, transaction).ToList();
pager.RecordCount = conn.Count <TEntity>(predicate, transaction, commandTimeout);
return(entities);
}
}
public UnitTest1()
{
var settings = new ConnectionSettings(new Uri("http://localhost:9200"))
.BasicAuthentication("elastic", "elasticpw")
.DefaultIndex("abp-audit-log");
_client = new ElasticClient(settings);
_list = new List <IPredicate>
{
Predicates.Field <AuditInfo>(x => x.UserId, Operator.Eq, 28),
Predicates.Field <AuditInfo>(x => x.MethodName, Operator.Like, "GetAll"),
Predicates.Field <AuditInfo>(x => x.UserId, Operator.Eq, 35, true)
};
_pg1 = new PredicateGroup {
Operator = GroupOperator.And
};
_pg1.Predicates.Add(Predicates.Field <AuditInfo>(x => x.UserId, Operator.Eq, 28));
_pg1.Predicates.Add(Predicates.Field <AuditInfo>(x => x.MethodName, Operator.Like, "GetAll"));
_pg2 = new PredicateGroup {
Operator = GroupOperator.Or
};
_pg2.Predicates.Add(Predicates.Field <AuditInfo>(x => x.UserId, Operator.Eq, 28));
_pg2.Predicates.Add(Predicates.Field <AuditInfo>(x => x.MethodName, Operator.Like, "GetAll"));
var pg4 = new PredicateGroup {
Operator = GroupOperator.And
};
pg4.Predicates.Add(Predicates.Field <AuditInfo>(x => x.UserId, Operator.Eq, 35));
pg4.Predicates.Add(Predicates.Field <AuditInfo>(x => x.MethodName, Operator.Like,
"GetRealtyProjectForEdit"));
_pg3 = new PredicateGroup {
Operator = GroupOperator.Or
};
_pg3.Predicates.Add(_pg1);
_pg3.Predicates.Add(pg4);
}
/// <summary>
/// 数据表 分页
/// </summary>
/// <param name="pageNum">指定页数 索引从0开始</param>
/// <param name="pageSize">指定每页多少项</param>
///<param name="outTotal">输出当前表的总项数</param>
/// <param name="expression">条件 linq表达式 谓词</param>
/// <param name="sortList">排序字段</param>
/// <returns></returns>
public IEnumerable <TEntity> GetPageData(int pageNum, int pageSize, out long outTotal,
Expression <Func <TEntity, bool> > expression = null, object sortList = null)
{
IPredicateGroup predicate = DapperLinqBuilder <TEntity> .FromExpression(expression); //转换Linq表达式
IList <ISort> sort = SortConvert(sortList); //转换排序接口
var conn = DbHandle.CreateConnectionAndOpen();
var tran = conn.BeginTransaction(IsolationLevel.ReadUncommitted);
try
{
var entities = conn.GetPage <TEntity>(predicate, sort, pageNum, pageSize, transaction: conn.BeginTransaction(IsolationLevel.ReadUncommitted));
outTotal = conn.Count <TEntity>(null);
return(entities);
}
finally
{
conn.CloseIfOpen();
}
}
public IEnumerable <TEntity> Page(int pageNum, int pageSize, out long outTotal,
Expression <Func <TEntity, bool> > expression = null, object sortList = null)
{
try
{
if (Conn.State == ConnectionState.Closed)
{
Conn.Open();
}
IPredicateGroup predicate = DapperLinqBuilder <TEntity> .FromExpression(expression);
IList <ISort> sort = SortConvert(sortList);
var entities = Conn.GetPage <TEntity>(predicate, sort, pageNum - 1, pageSize);
outTotal = Conn.Count <TEntity>(predicate);
return(entities);
}
finally
{
Conn.Close();
}
}
/// <summary>
/// 数据表 分页
/// </summary>
/// <param name="pageNum">指定页数 索引从0开始</param>
/// <param name="pageSize">指定每页多少项</param>
///<param name="outTotal">输出当前表的总项数</param>
/// <param name="expression">条件 linq表达式 谓词</param>
/// <param name="sortList">排序字段</param>
/// <returns></returns>
public IEnumerable <TEntity> GetPageData(int pageNum, int pageSize, out long outTotal,
Expression <Func <TEntity, bool> > expression = null, object sortList = null)
{
try
{
if (_Conn.State == ConnectionState.Closed)
{
_Conn.Open();
}
IPredicateGroup predicate = DapperLinqBuilder <TEntity> .FromExpression(expression); //转换Linq表达式
IList <ISort> sort = SortConvert(sortList); //转换排序接口
var entities = _Conn.GetPage <TEntity>(predicate, sort, pageNum, pageSize, transaction: _Conn.BeginTransaction(IsolationLevel.ReadUncommitted));
outTotal = _Conn.Count <TEntity>(null);
return(entities);
}
finally
{
_Conn.Close();
}
}
/// <summary>
/// 数据表 分页
/// </summary>
/// <param name="pager">页数信息</param>
/// <param name="expression">条件 linq表达式 谓词</param>
/// <param name="sortList">排序字段</param>
/// <returns></returns>
public Page <TEntity> GetPageData(Page <TEntity> pager, Expression <Func <TEntity, bool> > expression = null, object sortList = null)
{
int commandTimeout = 1800;
IPredicateGroup predicate = DapperLinqBuilder <TEntity> .FromExpression(expression); //转换Linq表达式
IList <ISort> sort = SortConvert(sortList); //转换排序接口
var conn = DbHandle.CreateConnectionAndOpen();
var tran = conn.BeginTransaction(IsolationLevel.ReadUncommitted);
try
{
var entities = conn.GetPage <TEntity>(predicate, sort, pager.PageIndex, pager.PageSize, tran);
var list = entities.ToList();
pager.TotalCount = conn.Count <TEntity>(predicate, tran, commandTimeout);
return(pager);
}
finally
{
conn.CloseIfOpen();
}
}
