EF封装类 增加版，增加从缓存中查找数据方法，供参考！_.NET_编程开发_程序员俱乐部

EF封装类 增加版，增加从缓存中查找数据方法，供参考！

这个类是抽象类，我这里增加了需要子类验证的方法ValidateEntity，方便扩展，若想直接使用该类，可以将该类更改成静态类，里面所有的方法都改成静态方法就可以直接调用了，可能有不足之处，欢迎大家在本文下面评论留言，共同完善，谢谢！

class="brush:csharp;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Objects.DataClasses;
using ZBService.Model;
using System.Linq.Expressions;
using System.Web;

namespace ZBService
{
    public abstract class ServiceBase<T> where T : EntityObject
    {
        /// <summary>
        /// EF上下文对象
        /// </summary>
        protected mZhaoBiaoEntities zbEntities = new mZhaoBiaoEntities();

        /// <summary>
        /// 判断是否存在
        /// </summary>
        /// <param name="whereExpr"></param>
        /// <returns></returns>
        public bool Exist(Expression<Func<T, bool>> whereExpr)
        {
            return (this.Count(whereExpr) > 0);
        }

        /// <summary>
        /// 获取记录数
        /// </summary>
        /// <param name="whereExpr"></param>
        /// <returns></returns>
        public int Count(Expression<Func<T, bool>> whereExpr)
        {
            return zbEntities.CreateObjectSet<T>().Where(whereExpr).Count();
        }

        /// <summary>
        /// 查找实体对象
        /// </summary>
        /// <param name="whereExpr"></param>
        /// <returns></returns>
        public T Find(Expression<Func<T, bool>> whereExpr)
        {
            return zbEntities.CreateObjectSet<T>().Where(whereExpr).FirstOrDefault();
        }

        /// <summary>
        /// 从缓存中查找实体对象
        /// </summary>
        /// <param name="whereExpr"></param>
        /// <param name="cacheKey"></param>
        /// <param name="expireTime"></param>
        /// <returns></returns>
        public T FindFromCache(Expression<Func<T, bool>> whereExpr, string cacheKey, DateTime expireTime)
        {
            T entity;
            object obj = HttpRuntime.Cache[cacheKey];
            if (obj == null)
            {
                entity = this.Find(whereExpr);
                HttpRuntime.Cache.Insert(cacheKey, entity, null, expireTime, System.Web.Caching.Cache.NoSlidingExpiration);
            }
            else
            {
                entity = obj as T;
            }
            return entity;
        }

        /// <summary>
        /// 查找实体对象列表
        /// </summary>
        /// <param name="whereExpr"></param>
        /// <returns></returns>
        public IEnumerable<T> FindList<TKey>(Expression<Func<T, bool>> whereExpr, Expression<Func<T, TKey>> orderbyExpr, int orderDirection)
        {
            return this.FindList<T, TKey>(whereExpr, t => t, orderbyExpr, orderDirection);
        }

        /// <summary>
        /// 从缓存中查找实体对象列表
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereExpr"></param>
        /// <param name="orderbyExpr"></param>
        /// <param name="orderDirection"></param>
        /// <param name="cacheKey"></param>
        /// <param name="expireTime"></param>
        /// <returns></returns>
        public IEnumerable<T> FindListFromCache<TKey>(Expression<Func<T, bool>> whereExpr, Expression<Func<T, TKey>> orderbyExpr, int orderDirection, string cacheKey, DateTime expireTime)
        {
            return this.FindListFromCache(whereExpr, t => t, orderbyExpr, orderDirection, -1, cacheKey, expireTime);
        }

        /// <summary>
        /// 查找实体对象列表
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereExpr"></param>
        /// <param name="selectExpr"></param>
        /// <param name="orderbyExpr"></param>
        /// <param name="orderDirection"></param>
        /// <param name="returnCount"></param>
        /// <returns></returns>
        public IEnumerable<TResult> FindList<TResult, TKey>(Expression<Func<T, bool>> whereExpr, Expression<Func<T, TResult>> selectExpr, Expression<Func<TResult, TKey>> orderbyExpr, int orderDirection, int returnCount = -1)
        {
            var result = zbEntities.CreateObjectSet<T>().Where(whereExpr).Select(selectExpr);
            if (result != null && result.Count() > 0)
            {
                if (orderDirection > 0)
                {
                    result = result.OrderByDescending(orderbyExpr);
                }
                else
                {
                    result = result.OrderBy(orderbyExpr);
                }

                if (returnCount > 0)
                {
                    result = result.Take(returnCount);
                }

                return result.ToList();
            }
            return null;
        }

        /// <summary>
        /// 从缓存中查找对象列表
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereExpr"></param>
        /// <param name="selectExpr"></param>
        /// <param name="orderbyExpr"></param>
        /// <param name="orderDirection"></param>
        /// <param name="returnCount"></param>
        /// <param name="cacheKey"></param>
        /// <param name="expireTime"></param>
        /// <returns></returns>
        public IEnumerable<TResult> FindListFromCache<TResult, TKey>(Expression<Func<T, bool>> whereExpr, Expression<Func<T, TResult>> selectExpr, Expression<Func<TResult, TKey>> orderbyExpr, int orderDirection,
                                    int returnCount, string cacheKey, DateTime expireTime)
        {
            IEnumerable<TResult> resultList;
            object obj = HttpRuntime.Cache[cacheKey];
            if (obj == null)
            {
                resultList = this.FindList(whereExpr, selectExpr,orderbyExpr, orderDirection,returnCount);
                HttpRuntime.Cache.Insert(cacheKey, resultList, null, expireTime, System.Web.Caching.Cache.NoSlidingExpiration);
            }
            else
            {
                resultList = obj as IEnumerable<TResult>;
            }
            return resultList;
        }

        /// <summary>
        /// 分页查找实体对象列表
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereExpr"></param>
        /// <param name="selectExpr"></param>
        /// <param name="orderbyExpr"></param>
        /// <param name="orderDirection"></param>
        /// <param name="pageSize"></param>
        /// <param name="pageNo"></param>
        /// <param name="recordCount"></param>
        /// <returns></returns>
        public IEnumerable<TResult> FindListByPage<TResult, TKey>(Expression<Func<T, bool>> whereExpr, Expression<Func<T, TResult>> selectExpr, Expression<Func<TResult, TKey>> orderbyExpr, int orderDirection, int pageSize, int pageNo, out int recordCount)
        {
            recordCount = 0;
            var result = zbEntities.CreateObjectSet<T>().Where(whereExpr).Select(selectExpr);
            if (result == null) return null;
            recordCount = result.Count();

            if (pageNo > recordCount) pageNo = recordCount;
            if (pageNo <= 0) pageNo = 1;

            if (recordCount > 0)
            {
                if (recordCount > pageSize)
                {
                    if (orderDirection > 0)
                    {
                        return result.OrderByDescending(orderbyExpr).Skip((pageNo - 1) * pageSize).Take(pageSize).ToList();
                    }
                    else
                    {
                        return result.OrderBy(orderbyExpr).Skip((pageNo - 1) * pageSize).Take(pageSize).ToList();
                    }
                }
                else
                {
                    if (orderDirection > 0)
                    {
                        return result.OrderByDescending(orderbyExpr).ToList();
                    }
                    else
                    {
                        return result.OrderBy(orderbyExpr).ToList();
                    }
                }

            }
            return null;
        }

        /// <summary>
        /// 从缓存中分页查找实体对象列表
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereExpr"></param>
        /// <param name="selectExpr"></param>
        /// <param name="orderbyExpr"></param>
        /// <param name="orderDirection"></param>
        /// <param name="pageSize"></param>
        /// <param name="pageNo"></param>
        /// <param name="recordCount"></param>
        /// <param name="cacheKey"></param>
        /// <param name="expireTime"></param>
        /// <returns></returns>
        public IEnumerable<TResult> FindListByPageFromCache<TResult, TKey>(Expression<Func<T, bool>> whereExpr, Expression<Func<T, TResult>> selectExpr, Expression<Func<TResult, TKey>> orderbyExpr, int orderDirection, int pageSize, int pageNo, out int recordCount,
                    string cacheKey, DateTime expireTime)
        {
            recordCount = 0;
            IQueryable<TResult> result;
            object obj = HttpRuntime.Cache[cacheKey];
            if (obj == null)
            {
                result = zbEntities.CreateObjectSet<T>().Where(whereExpr).Select(selectExpr);
            }
            else
            {
                result = obj as IQueryable<TResult>;
            }

            if (result == null) return null;
            recordCount = result.Count();


            if (pageNo > recordCount) pageNo = recordCount;
            if (pageNo <= 0) pageNo = 1;

            if (recordCount > 0)
            {
                if (recordCount > pageSize)
                {
                    if (orderDirection > 0)
                    {
                        return result.OrderByDescending(orderbyExpr).Skip((pageNo - 1) * pageSize).Take(pageSize).ToList();
                    }
                    else
                    {
                        return result.OrderBy(orderbyExpr).Skip((pageNo - 1) * pageSize).Take(pageSize).ToList();
                    }
                }
                else
                {
                    if (orderDirection > 0)
                    {
                        return result.OrderByDescending(orderbyExpr).ToList();
                    }
                    else
                    {
                        return result.OrderBy(orderbyExpr).ToList();
                    }
                }

            }
            return null;

        }

        /// <summary>
        /// 增加实体
        /// </summary>
        /// <param name="entity"></param>
        public virtual void Add(T entity)
        {
            this.ValidateEntity(entity, ValidateMode.Add);
            zbEntities.CreateObjectSet<T>().AddObject(entity);
        }


        /// <summary>
        /// 增加实体列表
        /// </summary>
        /// <param name="entities"></param>
        public virtual void AddList(IEnumerable<T> entities)
        {
            var objSet = zbEntities.CreateObjectSet<T>();
            foreach (T entity in entities)
            {
                this.ValidateEntity(entity, ValidateMode.Add);
                objSet.AddObject(entity);
            }
        }

        /// <summary>
        /// 更新已分离实体,若未分离则不需要执行该方法
        /// </summary>
        /// <param name="entity"></param>
        public virtual void Update(T entity)
        {
            this.ValidateEntity(entity, ValidateMode.Update);
            zbEntities.CreateObjectSet<T>().ApplyCurrentValues(entity);
        }

        /// <summary>
        /// 删除实体
        /// </summary>
        /// <param name="entity"></param>
        public virtual void Delete(T entity)
        {
            this.ValidateEntity(entity, ValidateMode.Delete);
            zbEntities.CreateObjectSet<T>().DeleteObject(entity);
        }

        /// <summary>
        /// 删除实体
        /// </summary>
        /// <param name="whereExpr"></param>
        public virtual void Delete(Expression<Func<T, bool>> whereExpr)
        {
            var objSet = zbEntities.CreateObjectSet<T>();
            T entity = objSet.Where(whereExpr).Single();
            //this.ValidateEntity(entity, ValidateMode.Delete);
            objSet.DeleteObject(entity);
        }

        /// <summary>
        /// 删除实体列表
        /// </summary>
        /// <param name="entities"></param>
        public virtual void DeleteList(IEnumerable<T> entities)
        {
            var objSet = zbEntities.CreateObjectSet<T>();
            foreach (T entity in entities)
            {
                //this.ValidateEntity(entity, ValidateMode.Delete);
                objSet.DeleteObject(entity);
            }
        }


        /// <summary>
        /// 提交保存所有变更操作
        /// </summary>
        public void SubmitSave()
        {
            zbEntities.SaveChanges();
        }


        /// <summary>
        /// 验证
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        protected virtual void ValidateEntity(T entity, ValidateMode mode = ValidateMode.Add)
        {

        }

        /// <summary>
        /// 验证模式
        /// </summary>
        protected enum ValidateMode
        {
            Add = 0,
            Update = 1,
            Delete = -1
        }

    }
}

之前发表的文章详见：http://www.cnblogs.com/zuowj/p/4259515.html