Entity Framework Code First 公用扩展方法

 

Entity Framework Code First 公用扩展方法

今天用了EF，觉得挺方便的，但也有一个问题，一些相同的操作每个表都要重写，如：增、删、改、查。

那岂不是又多了很多工作量，于是就有下面的泛型扩展类：

    /// <summary>
    /// 业务层基类
    /// </summary>
    public class BusinessBase<T> where T:class
    {
        public DataContainerContext Context()
        {
            return new DataContainerContext();
        }

        /// <summary>  
        /// 添加一个对象
        /// </summary>  
        /// <param name="entity">待添加的对象</param>  
        public virtual int AddObject(T entity)
        {
            using (var context = Context())
            {
                context.Entry(entity).State = EntityState.Added;
                return context.SaveChanges();
            }
        }

        /// <summary>  
        /// 根据实体的实体键修改实体，传入新的实体。
        /// </summary>  
        /// <param name="entity">修改新的对象</param>  
        public virtual int UpdateObject(T entity)
        {
            using (var context = Context())
            {
                context.Entry(entity).State=EntityState.Modified;
                return context.SaveChanges();
            }
        }

        /// <summary>  
        /// 删除一个对象，传入新的实体。
        /// </summary>  
        /// <param name="entity">待删除新的对象</param>  
        public virtual int DeleteObject(T entity)
        {
            using (var context = Context())
            {
                context.Entry(entity).State = EntityState.Deleted;
                return context.SaveChanges();
            }
        }


        /// <summary>  
        /// 根据条件获取某个对象  
        /// </summary>  
        /// <typeparam name="T">实体类型</typeparam>  
        /// <param name="where">查询条件</param>  
        /// <returns>实体</returns>  
        public virtual T GetEntity(params object[] keyValues)
        {
            using (var context = Context())
            {
                return context.Set<T>().Find(keyValues);
            }
        }

        /// <summary>  
        /// 根据条件获取某个对象  
        /// </summary>  
        /// <typeparam name="T">实体类型</typeparam>  
        /// <param name="where">查询条件</param>  
        /// <returns>实体</returns>  
        public virtual T GetEntity(Expression<Func<T, bool>> where)
        {
            using (var context = Context())
            {
                return context.Set<T>().Where(where).FirstOrDefault();
            }
        }

        /// <summary>  
        /// 根据条件进行查询  
        /// </summary>  
        /// <typeparam name="T">实体类型</typeparam>  
        /// <param name="where">查询条件</param>  
        /// <returns>符合条件的实体的集合</returns>  
        public virtual List<T> FindList(Func<T, bool> where)
        {
            using (var context = Context())
            {
                return context.Set<T>().Where(where).ToList();
            }
        }

        /// <summary>  
        /// 根据多个条件进行查询  
        /// </summary>  
        /// <typeparam name="T">实体类型</typeparam>  
        /// <param name="where">查询条件</param>  
        /// <returns>符合条件的实体的集合</returns>  
        public virtual List<T> FindList(params Func<T, bool>[] where)
        {
            using (var context = Context())
            {
                IEnumerable<T> query = context.Set<T>();
                if (where != null && where.Length > 0)
                {
                    for (int i = 0; i < where.Length; i++)
                    {
                        query = query.Where(where[i]);
                    }
                }
                return query.ToList();
            }
        }

        /// <summary>
        /// 根据条件进行查询
        /// </summary>
        /// <param name="sort">排序字段</param>
        /// <param name="order">排序顺序</param>
        /// <param name="startIndex">开始页</param>
        /// <param name="pageSize">页数</param>
        /// <param name="where">查询条件</param>
        /// <returns></returns>
        public virtual List<T> FindList(string sort, string order, int startIndex, int pageSize, params Func<T, bool>[] where)
        {
            using (var context = Context())
            {
                IEnumerable<T> query = context.Set<T>();
                if (where != null && where.Length > 0)
                {
                    for (int i = 0; i < where.Length; i++)
                    {
                        query = query.Where(where[i]);
                    }
                }
                if (!string.IsNullOrEmpty(sort) && sort.Trim().Length > 0)
                    query = query.AsQueryable().SortBy<T>(sort, LinqExpand.GetSortDirection(order));
                query = query.Skip(startIndex).Take(pageSize);
                return query.ToList();
            }
        }

        /// <summary>
        /// 根据条件进行查询
        /// </summary>
        /// <param name="startIndex">开始页</param>
        /// <param name="pageSize">页数</param>
        /// <returns></returns> 
        public virtual List<T> FindList(int startIndex, int pageSize)
        {
            using (var context = Context())
            {
                IEnumerable<T> query = context.Set<T>();
                query = query.Skip(startIndex).Take(pageSize);
                return query.ToList();
            }
        }

        /// <summary>
        /// 总数
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        public virtual int FindListCount(Func<T, bool> where)
        {
            using (var context = Context())
            {
                int count = context.Set<T>().Where(where).Count();
                return count;
            }
        }

        /// <summary>  
        /// 根据条件进行查询  
        /// </summary>  
        /// <typeparam name="T">实体类型</typeparam>  
        /// <param name="where">查询条件</param>  
        /// <returns>符号条件的实体的集合</returns>  
        public virtual int FindListCount(params Func<T, bool>[] where)
        {
            using (var context = Context())
            {
                IEnumerable<T> query = context.Set<T>();
                if (where != null && where.Length > 0)
                {
                    for (int i = 0; i < where.Length; i++)
                    {
                        query = query.Where(where[i]);
                    }
                }
                return query.Count();
            }
        }
    ｝

    #region 扩展
    /// <summary>
    /// linq扩展类
    /// </summary>
    public static class LinqExpand
    {
        /// <summary>
        /// Linq排序扩展方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <param name="propertyName">属性的字符串名称</param>
        /// <param name="sort">方向</param>
        /// <returns></returns>
        public static IQueryable<T> SortBy<T>(this IQueryable<T> source, string propertyName, SortDirectionEnum sort)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            if (String.IsNullOrEmpty(propertyName) || propertyName.Trim().Length == 0)
            {
                return source;
            }
            ParameterExpression parameter = Expression.Parameter(source.ElementType, String.Empty);
            MemberExpression property = Expression.Property(parameter, propertyName);
            LambdaExpression lambda = Expression.Lambda(property, parameter);
            string methodName = (sort == SortDirectionEnum.Ascending) ? "OrderBy" : "OrderByDescending";
            Expression methodCallExpression = Expression.Call(typeof(Queryable), methodName, new Type[] { source.ElementType, property.Type }, source.Expression, Expression.Quote(lambda));
            return source.Provider.CreateQuery<T>(methodCallExpression);

        }

        public static IQueryable<T> SearchBy<T>(this IQueryable<T> source, string propertyName, object value)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            if (String.IsNullOrEmpty(propertyName) || propertyName.Trim().Length == 0)
            {
                return source;
            }
            ParameterExpression parameter = Expression.Parameter(source.ElementType, String.Empty);
            MemberExpression property = Expression.Property(parameter, propertyName);
            LambdaExpression lambda = Expression.Lambda(property, parameter);
            string methodName = "Where";
            Expression methodCallExpression = Expression.Call(typeof(Queryable), methodName, new Type[] { source.ElementType, property.Type }, source.Expression, Expression.Quote(lambda));
            return source.Provider.CreateQuery<T>(methodCallExpression);

        }



        public static SortDirectionEnum GetSortDirection(string sortOrder)
        {
            if (sortOrder.ToLower() == "asc")
                return SortDirectionEnum.Ascending;
            else
                return SortDirectionEnum.Descending;
        }


    }
    /// <summary>
    /// 指定对项列表进行排序的方向。
    /// </summary>
    public enum SortDirectionEnum
    {
        /// <summary>
        /// 从小到大排序。例如，从 A 到 Z。
        /// </summary>
        Ascending = 0,
        /// <summary>
        /// 从大到小排序。例如，从 Z 到 A。
        /// </summary>
        Descending = 1,
    }

使用业务层都继承BusinessBase，如：public class UserBLL:BusinessBase<UserInfo>{}

 这样UserBLL就继承增、删、改、查这些方法了。

---