对EF的封装

using system;
using system.collections.generic;
using system.linq;
using system.text;
using system.data.objects.dataclasses;
using zbservice.model;
using system.linq.expressions;

namespace zbservice
{
    public abstract class servicebase<t> where t:entityobject
    {
        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>
        /// <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="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 (returncount > 0)
                {
                    if (orderdirection > 0)
                    {
                        result = result.orderbydescending(orderbyexpr).take(returncount);
                    }
                    else
                    {
                        result = result.orderby(orderbyexpr).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="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)
        {
            var result = zbentities.createobjectset<t>().where(whereexpr).select(selectexpr);
            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
        }

    }
}

c#

转发地址：https://www.cnblogs.com/zuowj/p/4259515.html