在数据仓储的情况下进一步封装数据库基础操作，此版本为异步版本

/// <summary>
/// 在数据仓储的情况下进一步封装数据库基础操作，此版本为异步版本 Created by ZhangQC 2016.08.17
/// </summary>
public static partial class EntityExtend
{
/// <summary>
/// 日志
/// </summary>
private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

#region 数据库查询

/// <summary>
/// 根据实体和条件获取数据库对应表 Created by ZhangQC 2016.08.17
/// </summary>
/// <typeparam name="T">泛指Entity</typeparam>
/// <param name="entity">数据库实体</param>
/// <param name="where">查询条件</param>
/// <returns></returns>
public static async Task<IEnumerable<T>> GetTableAsync<T>(this T entity, Expression<Func<T, bool>> where = null) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
return @where != null ? db.DoQuery(@where).ToList() : db.DoQuery().ToList();
}
}
catch (Exception ex)
{
Log.ErrorFormat("根据实体和条件获取数据库对应表出错：{0}", ex);
throw new ApplicationException("数据库查询失败");
}
});
}

/// <summary>
/// 获取表总数
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <param name="where"></param>
/// <returns></returns>
public static async Task<int> GetCount<T>(this T entity, Expression<Func<T, bool>> where = null) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
return @where != null ? db.DoQuery(@where).Count() : db.DoQuery().Count();
}
}
catch (Exception ex)
{
Log.ErrorFormat("获取表总数量出错：{0}", ex);
throw new ApplicationException("数据库查询失败");
}
});
}


/// <summary>
/// 查询数据，支持分页，排序，过滤操作 倒叙
/// </summary>
/// <remarks>"此方法完全是为了兼容MVCPager定制，不属于框架部分"</remarks>
/// <returns></returns>
public static async Task<PagedList<T>> GetTableBySortDescPageListAsync<T>(this T entity, int pageIndex, int pageSize, Expression<Func<T, bool>> where = null,
Expression<Func<T, object>> sort = null) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
var table = @where != null
? db.DoQuery(@where)
: db.DoQuery();
//如果排序为null，那么就按实体其中的一个主键进行排序
if (sort == null)
{
var entitySet = db.EntitySet<T>();
var keyCollections = entitySet.ElementType.KeyMembers;
if (keyCollections.FirstOrDefault() == null)
{
throw new ApplicationException("要查询的表没有发现主键！");
}
//自动生成主键排序字段
var entityKey = keyCollections.Aggregate(string.Empty, (a, b) => a + b + " desc,").TrimEnd(',');
//排序后的IQuaryable
var tableSortNull = table.OrderUsingSortExpression(entityKey);
return tableSortNull.ToPagedList(pageIndex, pageSize);
}
var tableSort = table.OrderBy(@sort);
return tableSort.ToPagedList(pageIndex, pageSize);
}
}
catch (Exception ex)
{
Log.ErrorFormat("对指定实体进行查询，可以分页，可以排序出错：{0}", ex);
throw new ApplicationException("数据库查询失败");
}
});
}

/// <summary>
/// 查询数据，支持分页，排序，过滤操作 正叙
/// </summary>
/// <remarks>"此方法完全是为了兼容MVCPager定制，不属于框架部分"</remarks>
/// <returns></returns>
public static async Task<PagedList<T>> GetTableBySortAscPageListAsync<T>(this T entity, int pageIndex, int pageSize, Expression<Func<T, bool>> where = null,
Expression<Func<T, object>> sort = null) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
var table = @where != null
? db.DoQuery(@where)
: db.DoQuery();
//如果排序为null，那么就按实体其中的一个主键进行排序
if (sort == null)
{
var entitySet = db.EntitySet<T>();
var keyCollections = entitySet.ElementType.KeyMembers;
if (keyCollections.FirstOrDefault() == null)
{
throw new ApplicationException("要查询的表没有发现主键！");
}
//自动生成主键排序字段
var entityKey =
keyCollections.Aggregate(string.Empty, (a, b) => a + b + " asc,").TrimEnd(',');

#region 注释代码，警醒用

//主键类型
//var type = ((EdmProperty) keyCollections).PrimitiveType.ClrEquivalentType;
//创建实例
//var entityActivator = Activator.CreateInstance<T>();
////创建类型实例
//var tKeyActivator = Activator.CreateInstance(type);

#endregion

//排序后的IQuaryable
var tableSortNull = table.OrderUsingSortExpression(entityKey);
return tableSortNull.ToPagedList(pageIndex, pageSize);
}
var tableSort = table.OrderBy(@sort);
return tableSort.ToPagedList(pageIndex, pageSize);
}
}
catch (Exception ex)
{
Log.ErrorFormat("对指定实体进行查询，可以分页，可以排序出错：{0}", ex);
throw new ApplicationException("数据库查询失败");
}
});
}

 

/// <summary>
/// 根据实体和条件获取数据库对应表 Created by ZhangQC 2016.08.17
/// </summary>
/// <typeparam name="T">泛指Entity</typeparam>
/// <param name="entity">数据库实体</param>
/// <param name="where">查询条件</param>
/// <returns></returns>
public static async Task<T> GetTableSingleAsync<T>(this T entity, Expression<Func<T, bool>> where = null) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
return @where != null ? db.DoQuery(@where).FirstOrDefault() : db.DoQuery().FirstOrDefault();
}
}
catch (Exception ex)
{
Log.ErrorFormat("根据实体和条件获取数据库对应表出错：{0}", ex);
throw new ApplicationException("数据库查询失败");
}
});
}

 


/// <summary>
/// 根据实体和条件查询数据库对应表加排序功能 Created by ZhangQC 2016.08.17
/// </summary>
/// <typeparam name="T">泛指实体</typeparam>
/// <param name="entity">数据库实体</param>
/// <param name="where">泛指查询条件表达式</param>
/// <param name="sort">泛指排序表达式</param>
/// <returns></returns>
public static async Task<IEnumerable<T>> GetTableBySortAsync<T>(this T entity, Expression<Func<T, bool>> where = null,
Func<T, object> sort = null) where T : class
{
try
{
var table = await entity.GetTableAsync(@where);
return @sort != null ? table.OrderBy(@sort).ToList() : table.ToList();
}
catch (Exception ex)
{
Log.ErrorFormat("根据实体和条件查询数据库对应表加排序功能出错：{0}", ex);
throw new ApplicationException("数据库查询失败");
}
}


/// <summary>
/// 根据实体和条件查询数据库对应表加排序功能 Created by ZhangQC 2016.08.17
/// </summary>
/// <typeparam name="T">泛指实体</typeparam>
/// <param name="entity">数据库实体</param>
/// <param name="where">泛指查询条件表达式</param>
/// <param name="sort">泛指排序表达式</param>
/// <returns></returns>
public static async Task<IEnumerable<T>> GetTableBySortDescAsync<T>(this T entity, Expression<Func<T, bool>> where = null,
Func<T, object> sort = null) where T : class
{
try
{
var table = await entity.GetTableAsync(@where);
return @sort != null ? table.OrderByDescending(@sort).ToList() : table.ToList();
}
catch (Exception ex)
{
Log.ErrorFormat("根据实体和条件查询数据库对应表加排序功能出错：{0}", ex);
throw new ApplicationException("数据库查询失败");
}
}

 

/// <summary>
/// 对指定实体进行查询，可以分页，可以排序 Created by ZhangQC 2016.08.17
/// </summary>
/// <typeparam name="T">泛指实体</typeparam>
/// <param name="entity">数据库实体</param>
/// <param name="skip">从多少条开始</param>
/// <param name="take">共取多少条</param>
/// <param name="where">泛指查询条件表达式</param>
/// <param name="sort">泛指排序表达式</param>
/// <returns></returns>
public static async Task<IEnumerable<T>> GetTableBySoryPageAsync<T>(this T entity, int? skip, int? take, Expression<Func<T, bool>> where = null,
Expression<Func<T, object>> sort = null) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
var table = @where != null
? db.DoQuery(@where)
: db.DoQuery();
if (@skip == null || @take == null)
return @sort != null ? table.OrderBy(@sort).ToList() : table.ToList();
//如果排序为null，那么就按实体其中的一个主键进行排序
if (sort == null)
{
var entitySet = db.EntitySet<T>();
var keyCollections = entitySet.ElementType.KeyMembers;
if (keyCollections.FirstOrDefault() == null)
{
throw new ApplicationException("要查询的表没有发现主键！");
}
//自动生成主键排序字段
var entityKey = keyCollections.Aggregate(string.Empty, (a, b) => a + b + " asc,").TrimEnd(',');
//排序后的IQuaryable
var tableSortNull = table.OrderUsingSortExpression(entityKey);
return tableSortNull.Skip((int)@skip).Take((int)@take).ToList();
}
var tableSort = table.OrderBy(@sort);
return tableSort.Skip((int)@skip).Take((int)@take).ToList();
}
}
catch (Exception ex)
{
Log.ErrorFormat("对指定实体进行查询，可以分页，可以排序出错：{0}", ex);
throw new ApplicationException("数据库查询失败");
}
});
}
/// <summary>
/// 对指定实体进行查询，可以分页，可以排序 倒序 Created by ZhangQC 2016.08.17
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <param name="skip"></param>
/// <param name="take"></param>
/// <param name="where"></param>
/// <param name="sort"></param>
/// <returns></returns>
public static async Task<IEnumerable<T>> GetTableBySoryDescPageAsync<T>(this T entity, int? skip, int? take, Expression<Func<T, bool>> where = null,
Expression<Func<T, object>> sort = null) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
var table = @where != null
? db.DoQuery(@where)
: db.DoQuery();
if (@skip == null || @take == null)
return @sort != null ? table.OrderByDescending(@sort).ToList() : table.ToList();
//如果排序为null，那么就按实体其中的一个主键进行排序
if (sort == null)
{
var entitySet = db.EntitySet<T>();
var keyCollections = entitySet.ElementType.KeyMembers;
if (keyCollections.FirstOrDefault() == null)
{
throw new ApplicationException("要查询的表没有发现主键！");
}
//自动生成主键排序字段
var entityKey = keyCollections.Aggregate(string.Empty, (a, b) => a + b + " desc,").TrimEnd(',');
//排序后的IQuaryable
var tableSortNull = table.OrderUsingSortExpression(entityKey);
return tableSortNull.Skip((int)@skip).Take((int)@take).ToList();
}
var tableSort = table.OrderBy(@sort);
return tableSort.Skip((int)@skip).Take((int)@take).ToList();
}
}
catch (Exception ex)
{
Log.ErrorFormat("对指定实体进行查询，可以分页，可以排序出错：{0}", ex);
throw new ApplicationException("数据库查询失败");
}
});
}

#endregion

#region 保存数据
/// <summary>
/// 单个实体保存数据库时使用 Created by ZhangQC 2016.08.17
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
public static async Task<bool> SaveAsync<T>(this T entity) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
db.Add(entity);
return db.Save() != 0;
}
}
catch (Exception ex)
{
Log.ErrorFormat("单个实体保存数据库时使用出错：{0}", ex);
return false;
}
});
}

 

/// <summary>
/// 实体集合新增或者更新数据库时使用 Created by ZhangQC 2016.08.17
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entityList"></param>
/// <returns></returns>
public static async Task<bool> SaveAsync<T>(this List<T> entityList) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
db.AddOrUpdate(entityList.ToArray());
db.Save();
return true;
}
}
catch (Exception ex)
{
Log.ErrorFormat("实体集合新增或者更新数据库时使用:{0}", ex);
return false;
}
});
}
#endregion


#region 更新操作
/// <summary>
/// 更新实体数据(批量可以使用Sava（List《T》）方法) Created by ZhangQC 2016.08.17
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
public static async Task<bool> UpdateAsync<T>(this T entity) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
db.Update(entity);
return db.Save() != 0;
}
}
catch (Exception ex)
{
Log.ErrorFormat("更新实体数据(批量可以使用Sava（List《T》）方法)出错：{0}", ex);
return false;
}
});
}
#endregion

#region 删除操作
/// <summary>
/// 删除操作 Created by ZhangQC 2016.08.17
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
public static async Task<bool> DeleteAsync<T>(this T entity) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
db.Delete(entity);
return db.Save() != 0;
}
}
catch (Exception ex)
{
Log.ErrorFormat("出错：{0}", ex);
return false;
}
});
}

/// <summary>
/// 删除操作 Created by ZhangQC 2016.08.17
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
public static async Task<bool> DeleteAsync<T>(this IQueryable<T> entity) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
db.Delete(entity);
return db.Save() != 0;
}
}
catch (Exception ex)
{
Log.ErrorFormat("出错：{0}", ex);
return false;
}
});
}


/// <summary>
/// 批量删除操作 Created by ZhangQC 2016.08.17
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
public static async Task<bool> DeleteAsync<T>(this IEnumerable<T> entity) where T : class
{
return await Task.Run(() =>
{
try
{
using (var db = new Repository<T>(new EFContext().ContextRead))
{
db.Delete(entity);
return db.Save() != 0;
}
}
catch (Exception ex)
{
Log.ErrorFormat("出错：{0}", ex);
return false;
}
});
}


#endregion
}