前两篇简单谈了一些.Net Core的优势以及机构设计的一些思路，这一篇开始，我们将从零开始搭建架构，底层我们将采用EF来访问数据库，所以这篇我们将贴一下EF常用操作的基类。
简单介绍下一些类库将要实现的功能：
Business：业务实现层
Domains：实体（Model）
Service：接口
Data：数据库访问（EF或其他）
EasyCacheing：开源缓存管理
Tools：工具类库
其他的我们用到的时候再说；
接着说EF常用操作基类，我们将基类放在Data下，具体目录结构如下：
BaseEntity：实体基类，基础共有的放在这里面：
using System;
using System.Collections.Generic;
using System.Text; namespace Data
{
/// <summary>
/// Base class for entities
/// </summary>
///[Serializable]
public abstract partial class BaseEntity
{
/// <summary>
/// Gets or sets the entity identifier
/// </summary>
public string Id { get; set; }
public virtual Nullable<DateTime> CreateTime { get; set; }
public virtual string CreatePerson { get; set; }
public virtual Nullable<DateTime> UpdateTime { get; set; }
public virtual string UpdatePerson { get; set; } public BaseEntity()
{
this.Id = GetIdentifier();
this.CreateTime = DateTime.Now;
this.UpdateTime = DateTime.Now;
} private string GetIdentifier()
{
return Guid.NewGuid().ToString();
} public override bool Equals(object obj)
{
return Equals(obj as BaseEntity);
} private static bool IsTransient(BaseEntity obj)
{
return obj != null && Equals(obj.Id, default(string));
} private Type GetUnproxiedType()
{
return GetType();
} public virtual bool Equals(BaseEntity other)
{
if (other == null)
return false; if (ReferenceEquals(this, other))
return true; if (!IsTransient(this) &&
!IsTransient(other) &&
Equals(Id, other.Id))
{
var otherType = other.GetUnproxiedType();
var thisType = GetUnproxiedType();
return thisType.IsAssignableFrom(otherType) ||
otherType.IsAssignableFrom(thisType);
} return false;
} public static bool operator ==(BaseEntity x, BaseEntity y)
{
return Equals(x, y);
} public static bool operator !=(BaseEntity x, BaseEntity y)
{
return !(x == y);
}
}
}
DbContextExtensions：数据库操作扩展
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Reflection;
using System.Text; namespace Data
{
public static class DbContextExtensions
{
private static void CombineParams(ref DbCommand command, params object[] parameters)
{
if (parameters != null)
{
foreach (SqlParameter parameter in parameters)
{
if (!parameter.ParameterName.Contains("@"))
parameter.ParameterName = $"@{parameter.ParameterName}";
command.Parameters.Add(parameter);
}
}
} private static DbCommand CreateCommand(DatabaseFacade facade, string sql, out DbConnection dbConn, params object[] parameters)
{
DbConnection conn = facade.GetDbConnection();
dbConn = conn;
conn.Open();
DbCommand cmd = conn.CreateCommand();
if (facade.IsSqlServer())
{
cmd.CommandText = sql;
CombineParams(ref cmd, parameters);
}
return cmd;
} public static DataTable SqlQuery(this DatabaseFacade facade, string sql, params object[] parameters)
{
DbCommand cmd = CreateCommand(facade, sql, out DbConnection conn, parameters);
DbDataReader reader = cmd.ExecuteReader();
DataTable dt = new DataTable();
dt.Load(reader);
reader.Close();
conn.Close();
return dt;
} public static IEnumerable<T> SqlQuery<T>(this DatabaseFacade facade, string sql, params object[] parameters) where T : class, new()
{
DataTable dt = SqlQuery(facade, sql, parameters);
return dt.ToEnumerable<T>();
} public static IEnumerable<T> ToEnumerable<T>(this DataTable dt) where T : class, new()
{
PropertyInfo[] propertyInfos = typeof(T).GetProperties();
T[] ts = new T[dt.Rows.Count];
int i = ;
foreach (DataRow row in dt.Rows)
{
T t = new T();
foreach (PropertyInfo p in propertyInfos)
{
if (dt.Columns.IndexOf(p.Name) != - && row[p.Name] != DBNull.Value)
p.SetValue(t, row[p.Name], null);
}
ts[i] = t;
i++;
}
return ts;
}
}
}
IPagedList：分页接口
using System;
using System.Collections.Generic;
using System.Text; namespace Data
{
public interface IPagedList<T> : IList<T>
{
int PageIndex { get; }
int PageSize { get; }
int TotalCount { get; }
int TotalPages { get; }
bool HasPreviousPage { get; }
bool HasNextPage { get; }
}
}
PagedList：分页接口的实现
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text; namespace Data
{
/// <summary>
/// Paged list
/// </summary>
/// <typeparam name="T">T</typeparam>
public class PagedList<T> : List<T>, IPagedList<T>
{
/// <summary>
/// Ctor
/// </summary>
/// <param name="source">source</param>
/// <param name="pageIndex">Page index</param>
/// <param name="pageSize">Page size</param>
public PagedList(IQueryable<T> source, int pageIndex, int pageSize)
{
int total = source.Count();
this.TotalCount = total;
this.TotalPages = total / pageSize; if (total % pageSize > )
TotalPages++; this.PageSize = pageSize;
this.PageIndex = pageIndex;
this.AddRange(source.Skip((pageIndex - ) * pageSize).Take(pageSize).ToList());
} /// <summary>
/// Ctor
/// </summary>
/// <param name="source">source</param>
/// <param name="pageIndex">Page index</param>
/// <param name="pageSize">Page size</param>
public PagedList(IList<T> source, int pageIndex, int pageSize)
{
TotalCount = source.Count();
TotalPages = TotalCount / pageSize; if (TotalCount % pageSize > )
TotalPages++; this.PageSize = pageSize;
this.PageIndex = pageIndex;
this.AddRange(source.Skip((pageIndex - ) * pageSize).Take(pageSize).ToList());
} /// <summary>
/// Ctor
/// </summary>
/// <param name="source">source</param>
/// <param name="pageIndex">Page index</param>
/// <param name="pageSize">Page size</param>
/// <param name="totalCount">Total count</param>
public PagedList(IEnumerable<T> source, int pageIndex, int pageSize, int totalCount)
{
TotalCount = totalCount;
TotalPages = TotalCount / pageSize; if (TotalCount % pageSize > )
TotalPages++; this.PageSize = pageSize;
this.PageIndex = pageIndex;
this.AddRange(source);
} public int PageIndex { get; private set; }
public int PageSize { get; private set; }
public int TotalCount { get; private set; }
public int TotalPages { get; private set; } public bool HasPreviousPage
{
get { return (PageIndex > ); }
}
public bool HasNextPage
{
get { return (PageIndex + < TotalPages); }
}
}
}
IEnumerableExtensions：IEnumerable分页的扩展
using System.Collections.Generic;
using System.Linq; namespace Data
{
public static class IEnumerableExtensions
{
public static PagedList<TSource> ToPageList<TSource>(this IEnumerable<TSource> source, int pageIndex, int pageSize)
{
if (pageIndex < )
pageIndex = ;
int TotalCount = ;
List<TSource> resultList = new List<TSource>();
resultList = source.Skip((pageIndex - ) * pageSize).Take(pageSize).ToList(); ;
TotalCount = source.Count();
return new PagedList<TSource>(resultList, pageIndex, pageSize, TotalCount);
}
}
}
IRepository：数据库仓库访问接口
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions; namespace Data
{
public interface IRepository<T> where T : BaseEntity
{
/// <summary>
/// 通过ID获取单个实体
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
T GetById(object id);
/// <summary>
/// 插入单个实体
/// </summary>
/// <param name="entity">实体</param>
/// <returns></returns>
bool Insert(T entity);
/// <summary>
/// 插入单个实体并返回ID
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
object InsertAndGetId(T entity);
/// <summary>
/// 批量插入数据集
/// </summary>
/// <param name="entities">数据集</param>
void Insert(IEnumerable<T> entities);
/// <summary>
/// 更新单个实体
/// </summary>
/// <param name="entity">实体</param>
/// <returns></returns>
bool Update(T entity);
/// <summary>
/// 批量更新数据集
/// </summary>
/// <param name="entities"></param>
void Update(IEnumerable<T> entities);
/// <summary>
/// 删除单个实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
bool Delete(T entity);
/// <summary>
/// 批量删除
/// </summary>
/// <param name="entities">删除的数据集</param>
void Delete(IEnumerable<T> entities);
/// <summary>
/// 通过ID删除实体
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
bool DeleteById(object id);
/// <summary>
/// 通过ID（逗号分隔ID）批量删除
/// </summary>
/// <param name="ids"></param>
/// <returns></returns>
bool DeleteByIds(object ids);
/// <summary>
/// 通过Id列表批量删除
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
bool DeleteByIdList(List<object> list);
/// <summary>
/// 分页查询
/// </summary>
/// <param name="pageIndex">当前页</param>
/// <param name="pageSize">每页条数</param>
/// <param name="condition">lambda查询条件where</param>
/// <param name="orderName">排序字段 默认CreateTime</param>
/// <param name="sortOrder">排序方式 asc desc,默认CreateTime desc</param>
/// <returns></returns>
IPagedList<T> GetListForPaging(int pageIndex, int pageSize, Expression<Func<T, bool>> condition = null, string orderName = null, string sortOrder = null);
/// <summary>
/// Linq连表查询专用，获取单表所有数据请使用GetList
/// </summary>
IQueryable<T> Table { get; }
/// <summary>
/// 根据条件查找
/// </summary>
/// <param name="condition">lambda查询条件where</param>
/// <returns></returns>
T GetEntity(Expression<Func<T, bool>> condition);
/// <summary>
/// 分页查询(Linq分页方式)
/// </summary>
/// <param name="pageIndex">当前页</param>
/// <param name="pageSize">页码</param>
/// <param name="condition">lambda查询条件where</param>
/// <<param name="sort">排序key:排序字段，value:bool,true-desc，false-asc 默认：CreateTime desc</param>
/// <returns></returns>
IPagedList<T> GetListForPaging(int pageIndex, int pageSize, Expression<Func<T, bool>> condition = null, Dictionary<string, bool> sort = null);
/// <summary>
/// 执行原始SQL命令
/// </summary>
/// <param name="commandText">SQL命令</param>
/// <param name="parameters">参数</param>
/// <returns>影响的记录数</returns>
IEnumerable<TElement> SqlQuery<TElement>(string sql, params object[] parameters) where TElement : class, new();
/// <summary>
/// 执行SqlCommand
/// </summary>
/// <param name="sql">sql</param>
/// <param name="parameters">参数</param>
/// <returns></returns>
int ExecuteSqlCommand(string sql, params object[] parameters);
/// <summary>
/// 查询列表,默认返回整个表数据
/// </summary>
/// <param name="condition">lambda查询条件where</param>
/// <returns></returns>
List<T> GetList(Expression<Func<T, bool>> condition = null);
}
}
EFRepository：IEFRepository接口实现
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Tools.Cache; namespace Data
{
public class EFRepository<T> : IRepository<T> where T : BaseEntity
{
private DbContext _context;
private DbSet<T> _entities;
private IStaticCacheManager _cacheManager;
public EFRepository(DbContext context, IStaticCacheManager cacheManager)
{
this._context = context;
_cacheManager = cacheManager;
} private DbSet<T> Entities
{
get
{
if (_entities == null)
{
_entities = this._context.Set<T>();
}
return _entities;
}
}
/// <summary>
/// Linq连表查询专用，获取单表所有数据请使用GetList
/// </summary>
public virtual IQueryable<T> Table
{
get {
return this.Entities;
}
}
/// <summary>
/// 通过ID获取单个实体
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public virtual T GetById(object id)
{
var cacheKey = typeof(T).Name+".GetById."+id;
return _cacheManager.Get(cacheKey, ()=>this.Entities.Find(id));
}
/// <summary>
/// 插入单个实体
/// </summary>
/// <param name="entity">实体</param>
/// <returns></returns>
public virtual bool Insert(T entity)
{
if (entity == null)
throw new ArgumentNullException(nameof(entity)); try
{
Entities.Add(entity);
_context.SaveChanges();
var cacheContain = typeof(T).Name;
_cacheManager.RemoveByContain(cacheContain);
}
catch (DbUpdateException exception)
{
//ensure that the detailed error text is saved in the Log
throw new Exception(GetFullErrorTextAndRollbackEntityChanges(exception), exception);
}
return true;
}
/// <summary>
/// 插入单个实体并返回ID
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual object InsertAndGetId(T entity)
{
if (entity == null)
throw new ArgumentNullException(nameof(entity));
try
{
this.Entities.Add(entity);
this._context.SaveChanges();
var cacheContain = typeof(T).Name;
_cacheManager.RemoveByContain(cacheContain);
}
catch (DbUpdateException exception)
{
//ensure that the detailed error text is saved in the Log
throw new Exception(GetFullErrorTextAndRollbackEntityChanges(exception), exception);
}
return entity.Id;
}
/// <summary>
/// 批量插入数据集
/// </summary>
/// <param name="entities">数据集</param>
public virtual void Insert(IEnumerable<T> entities)
{
if (entities == null)
throw new ArgumentNullException(nameof(entities)); try
{
Entities.AddRange(entities);
_context.SaveChanges();
var cacheContain = typeof(T).Name;
_cacheManager.RemoveByContain(cacheContain);
}
catch (DbUpdateException exception)
{
//ensure that the detailed error text is saved in the Log
throw new Exception(GetFullErrorTextAndRollbackEntityChanges(exception), exception);
}
}
/// <summary>
/// 更新单个实体
/// </summary>
/// <param name="entity">实体</param>
/// <returns></returns>
public virtual bool Update(T entity)
{
if (entity == null)
throw new ArgumentNullException(nameof(entity));
try
{
this._context.Set<T>().Attach(entity);
Type _type = typeof(T);
PropertyInfo[] _properties = _type.GetProperties();
var entry = _context.Entry(entity);
foreach (PropertyInfo item in _properties)
{
if ("Id" == item.Name || "CreateTime" == item.Name || "CreatePerson" == item.Name)
{
continue;
} entry.Property(item.Name).IsModified = true;
}
this._context.SaveChanges();
var cacheContain = typeof(T).Name;
_cacheManager.RemoveByContain(cacheContain);
}
catch (DbUpdateException exception)
{
//ensure that the detailed error text is saved in the Log
throw new Exception(GetFullErrorTextAndRollbackEntityChanges(exception), exception);
}
return true;
}
/// <summary>
/// 批量更新数据集
/// </summary>
/// <param name="entities"></param>
public virtual void Update(IEnumerable<T> entities)
{
if (entities == null)
throw new ArgumentNullException(nameof(entities)); try
{
// Entities.UpdateRange(entities);
this._context.Set<T>().AttachRange(entities);
foreach (var entity in entities)
{
Type _type = typeof(T);
PropertyInfo[] _properties = _type.GetProperties();
var entry = _context.Entry(entity);
foreach (PropertyInfo item in _properties)
{
if ("Id" == item.Name || "CreateTime" == item.Name || "CreatePerson" == item.Name)
{
continue;
} entry.Property(item.Name).IsModified = true;
}
} _context.SaveChanges();
var cacheContain = typeof(T).Name;
_cacheManager.RemoveByContain(cacheContain);
}
catch (DbUpdateException exception)
{
//ensure that the detailed error text is saved in the Log
throw new Exception(GetFullErrorTextAndRollbackEntityChanges(exception), exception);
}
}
/// <summary>
/// 删除单个实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual bool Delete(T entity)
{
if (entity == null)
throw new ArgumentNullException(nameof(entity)); try
{
Entities.Remove(entity);
_context.SaveChanges();
var cacheContain = typeof(T).Name;
_cacheManager.RemoveByContain(cacheContain);
}
catch (DbUpdateException exception)
{
//ensure that the detailed error text is saved in the Log
throw new Exception(GetFullErrorTextAndRollbackEntityChanges(exception), exception);
}
return true;
}
/// <summary>
/// 批量删除
/// </summary>
/// <param name="entities">删除的数据集</param>
public virtual void Delete(IEnumerable<T> entities)
{
if (entities == null)
throw new ArgumentNullException(nameof(entities)); try
{
Entities.RemoveRange(entities);
_context.SaveChanges();
var cacheContain = typeof(T).Name;
_cacheManager.RemoveByContain(cacheContain);
}
catch (DbUpdateException exception)
{
//ensure that the detailed error text is saved in the Log
throw new Exception(GetFullErrorTextAndRollbackEntityChanges(exception), exception);
}
}
/// <summary>
/// 通过ID删除实体
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public virtual bool DeleteById(object id)
{
try
{
var item = this.Entities.Find(id);
if (item == null)
{
return false;
}
this.Entities.Remove(item);
this._context.SaveChanges();
var cacheContain = typeof(T).Name;
_cacheManager.RemoveByContain(cacheContain);
}
catch (DbUpdateException exception)
{
//ensure that the detailed error text is saved in the Log
throw new Exception(GetFullErrorTextAndRollbackEntityChanges(exception), exception);
}
return true;
}
/// <summary>
/// 通过ID（逗号分隔ID）批量删除
/// </summary>
/// <param name="ids"></param>
/// <returns></returns>
public virtual bool DeleteByIds(object ids)
{
try
{
var idArray = ids.ToString().Split(',');
for (int i = ; i < idArray.Length; i++)
{
var item = this.Entities.Find(idArray[i]);
if (item == null)
{
continue;
}
this.Entities.Remove(item);
}
this._context.SaveChanges();
var cacheContain = typeof(T).Name;
_cacheManager.RemoveByContain(cacheContain);
}
catch (DbUpdateException exception)
{
//ensure that the detailed error text is saved in the Log
throw new Exception(GetFullErrorTextAndRollbackEntityChanges(exception), exception);
}
return true;
}
/// <summary>
/// 通过Id列表批量删除
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
public virtual bool DeleteByIdList(List<object> list)
{
try
{
for (int i = ; i < list.Count; i++)
{
var item = this.Entities.Find(list[i]);
if (item == null)
{
continue;
}
this.Entities.Remove(item);
}
this._context.SaveChanges();
var cacheContain = typeof(T).Name;
_cacheManager.RemoveByContain(cacheContain);
}
catch (DbUpdateException exception)
{
//ensure that the detailed error text is saved in the Log
throw new Exception(GetFullErrorTextAndRollbackEntityChanges(exception), exception);
}
return true;
} /// <summary>
/// 根据条件查找
/// </summary>
/// <param name="condition">lambda查询条件where</param>
/// <returns></returns>
public virtual T GetEntity(Expression<Func<T, bool>> condition)
{
var cacheKey = typeof(T) + "GetSingleOrDefault.Condition."+ condition.ToString();
return _cacheManager.Get(cacheKey,()=>this.Entities.Where(condition).SingleOrDefault());
}
/// <summary>
/// 分页查询(Linq分页方式)
/// </summary>
/// <param name="pageIndex">当前页</param>
/// <param name="pageSize">页码</param>
/// <param name="condition">lambda查询条件where</param>
/// <param name="sort">排序key:排序字段，value:bool,true-desc，false-asc，默认：CreateTime desc</param>
/// <returns></returns>
public virtual IPagedList<T> GetListForPaging(int pageIndex, int pageSize, Expression<Func<T, bool>> condition = null, Dictionary<string, bool> sort = null)
{
if (pageIndex < )
pageIndex = ;
var cacheKey = typeof(T).Name;
cacheKey = cacheKey + ".GetList";
List<T> data = null; if (condition != null)
{
cacheKey = cacheKey+ ".Condition." + condition.ToString();
} data = _cacheManager.Get<List<T>>(cacheKey); if(data != null)
{
if (sort != null)
{
foreach (var item in sort)
{
data = data.AsQueryable().OrderBy(item.Key, item.Value).ToList();
}
}
else
{
data = data.AsQueryable().OrderByDescending(x => x.CreateTime).ToList();
}
}
else
{
if(condition!=null)
{
data = this.Entities.Where(condition).ToList();
}
else
{
data = this.Entities.ToList();
}
_cacheManager.Set(cacheKey, data, ); data = data.AsQueryable().OrderByDescending(x => x.CreateTime).ToList();//无缓存默认返回排序后数据
} return new PagedList<T>(data, pageIndex, pageSize);
} /// <summary>
/// 执行原始SQL命令
/// </summary>
/// <param name="commandText">SQL命令</param>
/// <param name="parameters">参数</param>
/// <returns>影响的记录数</returns>
public virtual IEnumerable<TElement> SqlQuery<TElement>(string sql, params object[] parameters) where TElement : class, new()
{
DataTable dt = this._context.Database.SqlQuery(sql, parameters);
return dt.ToEnumerable<TElement>(); }
/// <summary>
/// 分页查询
/// </summary>
/// <param name="pageIndex">当前页</param>
/// <param name="pageSize">每页条数</param>
/// <param name="condition">lambda查询条件where</param>
/// <param name="orderName">排序字段 默认CreateTime</param>
/// <param name="sortOrder">排序方式 asc desc,默认CreateTime desc</param>
/// <returns></returns>
public virtual IPagedList<T> GetListForPaging(int pageIndex, int pageSize, Expression<Func<T, bool>> condition = null, string orderName = null, string sortOrder = null)
{
var cachekey = typeof(T).Name;
if (pageIndex < )
pageIndex = ;
if (orderName == null)
{
orderName = "CreateTime";
}
bool isDesc = true;
if(sortOrder!=null&&sortOrder.ToLower() == "asc")
{
isDesc = false;
} cachekey = cachekey + ".GetList"; if(condition!=null)
{
cachekey = cachekey + ".Condition." + condition.ToString();
} List<T> resultList = null; var cacheData = _cacheManager.Get<List<T>>(cachekey);
if (cacheData != null)
{
resultList = cacheData.AsQueryable().OrderBy(orderName, isDesc).ToList();
}
else
{
if (condition == null)
{
resultList = Entities.ToList();
}
else
{
resultList = Entities.Where(condition).ToList();
}
_cacheManager.Set(cachekey, resultList, );
} return new PagedList<T>(resultList, pageIndex, pageSize);
}
/// <summary>
/// 执行SqlCommand
/// </summary>
/// <param name="sql">sql</param>
/// <param name="parameters">参数</param>
/// <returns></returns>
public virtual int ExecuteSqlCommand(string sql, params object[] parameters)
{
var result = this._context.Database.ExecuteSqlCommand(sql, parameters);
return result;
}
/// <summary>
/// 查询列表,默认返回整个表数据
/// </summary>
/// <param name="condition">lambda查询条件where</param>
/// <returns></returns>
public virtual List<T> GetList(Expression<Func<T, bool>> condition = null)
{
var cacheKey = typeof(T).Name+ ".GetList";
List<T> entities = null;
if (condition != null)
{
cacheKey = cacheKey + ".Condition." + condition.ToString();
entities = _cacheManager.Get(cacheKey,()=>this.Entities.Where(condition).ToList());
}
else
{
entities = _cacheManager.Get(cacheKey,()=>this.Entities.ToList());
}
return entities;
}
#region Utilities /// <summary>
/// Rollback of entity changes and return full error message
/// </summary>
/// <param name="exception">Exception</param>
/// <returns>Error message</returns>
protected string GetFullErrorTextAndRollbackEntityChanges(DbUpdateException exception)
{
//rollback entity changes
if (_context is DbContext dbContext)
{
var entries = dbContext.ChangeTracker.Entries()
.Where(e => e.State == EntityState.Added || e.State == EntityState.Modified).ToList(); entries.ForEach(entry =>
{
try
{
entry.State = EntityState.Unchanged;
}
catch (InvalidOperationException)
{
// ignored
}
});
} try
{
_context.SaveChanges();
return exception.ToString();
}
catch (Exception ex)
{
//if after the rollback of changes the context is still not saving,
//return the full text of the exception that occurred when saving
return ex.ToString();
}
} #endregion }
}
public static class QueryableExtensions
{
public static IQueryable<T> OrderBy<T>(this IQueryable<T> queryable, string propertyName)
{
return QueryableHelper<T>.OrderBy(queryable, propertyName, false);
}
public static IQueryable<T> OrderBy<T>(this IQueryable<T> queryable, string propertyName, bool desc)
{
return QueryableHelper<T>.OrderBy(queryable, propertyName, desc);
}
static class QueryableHelper<T>
{
private static Dictionary<string, LambdaExpression> cache = new Dictionary<string, LambdaExpression>();
public static IQueryable<T> OrderBy(IQueryable<T> queryable, string propertyName, bool desc)
{
dynamic keySelector = GetLambdaExpression(propertyName);
return desc ? Queryable.OrderByDescending(queryable, keySelector) : Queryable.OrderBy(queryable, keySelector);
}
private static LambdaExpression GetLambdaExpression(string propertyName)
{
if (cache.ContainsKey(propertyName)) return cache[propertyName];
var param = Expression.Parameter(typeof(T));
var body = Expression.Property(param, propertyName);
var keySelector = Expression.Lambda(body, param);
cache[propertyName] = keySelector;
return keySelector;
}
}
}
_cacheManager下篇我们讲到缓存管理的时候再来讲，包括依赖注入也放到下篇，今天就先到这里了！