框架搭建与EF常用基类实现

      前两篇简单谈了一些.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 = 0;
            foreach (DataRow row in dt.Rows)
            {
                T t = new T();
                foreach (PropertyInfo p in propertyInfos)
                {
                    if (dt.Columns.IndexOf(p.Name) != -1 && 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 > 0)
                TotalPages++;

            this.PageSize = pageSize;
            this.PageIndex = pageIndex;
            this.AddRange(source.Skip((pageIndex - 1) * 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 > 0)
                TotalPages++;

            this.PageSize = pageSize;
            this.PageIndex = pageIndex;
            this.AddRange(source.Skip((pageIndex - 1) * 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 > 0)
                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 > 0); }
        }
        public bool HasNextPage
        {
            get { return (PageIndex + 1 < 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 < 1)
                pageIndex = 1;
            int TotalCount = 0;
            List<TSource> resultList = new List<TSource>();
            resultList = source.Skip((pageIndex - 1) * 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 = 0; 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 = 0; 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 < 1)
                pageIndex = 1;
            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, 60);

                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 < 1)
                pageIndex = 1;
            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, 60);
            }
         
            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下篇我们讲到缓存管理的时候再来讲，包括依赖注入也放到下篇，今天就先到这里了！