Entity Framework 泛型使用

因为增删改查是我们常用到的方法，我们不可能每个数据模型都去完成增删改查，这样的办法太笨拙了。我们可以写个父类（包含增删改查），然后让所有的数据模型类继承该父类。那就要求我们的父类必须使用泛型来实现。

using System;
using System.Collections.Generic;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    /// <summary>
    /// 定义泛型,必须规定T为类，不然db.Set<T>会报错
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class DALBase<T> where T:class
    {
        //因为我们要操作数据库，所以先实例化一个上下文
        Model1Container db = new Model1Container();

        #region 添加方法
        /// <summary>
        /// 添加方法
        /// </summary>
        /// <param name="Model"></param>
        public void add(T Model)
        {
            db.Set<T>().Add(Model);
            db.SaveChanges();
        } 
        #endregion

        #region 修改单个实体
        /// <summary>
        /// 修改单个实体
        /// </summary>
        /// <param name="Model"></param>
        /// <param name="strs"></param>
        public void update(T Model, params string[] strs)
        {
            DbEntityEntry entry = db.Entry<T>(Model);
            entry.State = System.Data.EntityState.Unchanged;
            foreach (string tempStr in strs)
            {
                entry.Property(tempStr).IsModified = true;
            }
            db.SaveChanges();
        } 
        #endregion

        #region 批量修改，根据反射，稍微要复杂一些
        /// <summary>
        /// 批量修改，根据反射，稍微要复杂一些
        /// </summary>
        /// <param name="Model">将值存入属性中</param>
        /// <param name="where">批量修改的条件</param>
        /// <param name="strs">属性</param>
        public void updateBatch(T Model, Expression<Func<T, bool>> where, params string[] strs)
        {
            //先根据条件查出符合要修改的集合
            List<T> tempList = db.Set<T>().Where(where).ToList();
            //获取类型
            Type t = typeof(T);
            //利用反射获取T类型public属性集合
            List<PropertyInfo> tempPro = t.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance).ToList();
            Dictionary<string, PropertyInfo> propertyDic = new Dictionary<string, PropertyInfo>();
            //遍历T的所有属性，将符合修改的存入字典中
            tempPro.ForEach(p => { if (strs.Contains(p.Name)) { propertyDic.Add(p.Name, p); } });
            //遍历要修改的属性
            foreach (string str in strs)
            {
                if (propertyDic.ContainsKey(str))
                {
                    PropertyInfo propertyInfo = propertyDic[str];
                    //获取要修改属性的值
                    object value = propertyInfo.GetValue(Model, null);
                    foreach (T tempData in tempList)
                    {
                        //设置值
                        propertyInfo.SetValue(tempData, value, null);
                    }
                }
            }
        } 
        #endregion

        #region 根据实体id删除操作
        /// <summary>
        /// 根据实体id删除操作
        /// </summary>
        /// <param name="Model"></param>
        public void remove(T Model)
        {
            db.Set<T>().Attach(Model);
            db.Set<T>().Remove(Model);
            db.SaveChanges();
        } 
        #endregion

        #region 根据条件删除操作
        /// <summary>
        /// 根据条件删除操作
        /// </summary>
        /// <param name="remWhere"></param>
        public void removeByWhere(Expression<Func<T, bool>> remWhere)
        {
            List<T> tempList = db.Set<T>().Where(remWhere).ToList();
            tempList.ForEach(t => { db.Set<T>().Attach(t); db.Set<T>().Remove(t); });
            db.SaveChanges();
        } 
        #endregion

        #region 一般带条件查询
        /// <summary>
        /// 一般带条件查询
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        public List<T> getList(System.Linq.Expressions.Expression<Func<T, bool>> where)
        {
            return db.Set<T>().Where(where).ToList();
        } 
        #endregion

        #region 带条件排序，页码页容量查询
        /// <summary>
        /// 带条件排序，页码页容量查询
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="where"></param>
        /// <param name="orderBy"></param>
        /// <param name="pageSize"></param>
        /// <param name="pageIndex"></param>
        /// <returns></returns>
        public List<T> getListOrder<TKey>(Expression<Func<T, bool>> where, Expression<Func<T, TKey>> orderBy, int pageSize, int pageIndex)
        {
            return db.Set<T>().Where(where).OrderBy(orderBy).Skip(pageIndex - 1).Take(pageSize).ToList();
        } 
        #endregion
    }
}

里面用到了反射，可能有些复杂，EF要告一段落了，下面开始记录mvc学习历程了。以后可能还会写个小项目，使用mvc+EF