EntityFramework基础

 好久没有学习新东西了，最近研究了下EntityFramework，将基础代码贴出来，

Entity Framework 利用了抽象化数据结构的方式，将每个数据库对象都转换成应用程序对象 (entity)，而数据字段都转换为属性 (property)，关系则转换为结合属性 (association)，让数据库的 E/R 模型完全的转成对象模型，如此让程序设计师能用最熟悉的编程语言来调用访问。而在抽象化的结构之下，则是高度集成与对应结构的概念层、对应层和储存层，以 及支持 Entity Framework 的数据提供者 (provider)，让数据访问的工作得以顺利与完整的进行。

(1) 概念层：负责向上的对象与属性显露与访问。

(2) 对应层：将上方的概念层和底下的储存层的数据结构对应在一起。

(3) 储存层：依不同数据库与数据结构，而显露出实体的数据结构体，和 Provider 一起，负责实际对数据库的访问和 SQL 的产生。

预备知识：Linq、C#匿名类和拉姆达表达式、

废话不多说，直接上代码

一添加：首先创建试题对象，将要添加的数据复制到对象属性上，然后添加到数据库

   #region 添加
        static AdvEFEntities db = new AdvEFEntities();
        static void Add()
        {
            Guid id = new Guid("00000000-0000-0000-0000-000000000000");
            //创建实体对象
            AdvertisingArea advEF = new AdvertisingArea()
            {
                QuName = "1111",
                ShengId = 2,
                ShiId = 2,
                ShengName = "22222",
                ShiName = "23333",
                QuId = 2232,
            };
            //将对象添加到数据库中
            //将对象上下文存到AdvertisingArea集合中
            // db.Advertising.Add(advEF);
            DbEntityEntry<AdvertisingArea> entry = db.Entry<AdvertisingArea>(advEF);
            //设置数据状态
            entry.State = System.Data.EntityState.Added;
            db.SaveChanges();
            Console.WriteLine("数据添加完成");
        }
        #endregion

     二查询（1）单表查询：

        查询出QuName字段包含”我是新增“的数据

        #region 查询
        static void Query()
        {
            //变相的即时查询 
            List<AdvertisingArea> area = db.AdvertisingArea.Where(u => u.QuName.Contains("我是新增")).ToList();
            area.ForEach(u => Console.WriteLine(u.ToString()));
        }
        #endregion

　　　　关联查询（2）：关联查询要求数据库结构必须存在主外键关系，当生成试题类的时候EF会根据数据库结构生成出每张表的试题类，并且包含当前表的外键的映射关系

　　连接查询查询出CommonUser表和CommonUnit表 关联条件unitId=unitId

     #region 2.2 连接查询(生成 inner join) -void QueryInnerJoin()
        /// <summary>
        /// 2.2 连接查询(生成 inner join)
        /// </summary>
        static void QueryInnerJoin()
        {
            //通过Include方法，设置 EF 生成 sql 语句时，使用 inner join 把 地址表对应的 User属性 也查出来
            //   select * from CommonUser a inner join CommonUnit u on a.udId =u.id 
            Guid id = new Guid("00000000-0000-0000-0000-000000000000");
            IQueryable<CommonUser> addrs = db.CommonUser.Include("CommonUnit").Where(a => a.unitId == id);
            foreach (CommonUser add in addrs)
            {
                Console.WriteLine(add.loginName + ":userName=" + add.CommonUnit.unitName);
            }

        }
        #endregion

   三修改（1）官方推荐方法：首先查询出要修改的数据， 然后将修改后的数据重新复制个对象属性，然后保存到数据库

   #region 修改
        /// <summary>
        /// 
        /// </summary>
        static void Update()
        {
            //查询出一个 要修改的对象 -- 注意：此时返回的 是 一个 AdvertisingArea类的 代理类对象（包装类对象）
            AdvertisingArea area = db.AdvertisingArea.Where(u => u.Id == 24).FirstOrDefault();
            Console.WriteLine("修改前" + area.ToString());
            //2.修改内容 -- 注意：此时其实操作的 是 代理类对象 的属性，这些属性，会将 值 设置给 内部的 AdvertisingArea对象对应的属性，同时 标记此属性为已修改状态
            area.QuName = "1111111111111111111111111";
            //.重新保存到数据库 -- 注意：此时 ef上下文，会检查容器内部 所有的对象，找到 标记为修改的 对象，然后 找到 标记为修改的 对象属性，生成对应的 update语句 执行！
            db.SaveChanges();
            Console.WriteLine("修改后" + area.ToString());
        }
        #endregion

      修改（2）直接修改方法：
　　

   #region 直接修改
        /// <summary>
        /// 
        /// </summary>
        static void UpdateZhiJie()
        {
            //1.查询出一个 要修改的对象
            AdvertisingArea usr = new AdvertisingArea() { Id = 23, ShiName = "asdasdasdasdas" };
            //2.将 对象 加入 EF容器,并获取 当前实体对象 的 状态管理对象
            DbEntityEntry<AdvertisingArea> entry = db.Entry<AdvertisingArea>(usr);
            //3.设置 该对象 为被修改过
            entry.State = System.Data.EntityState.Unchanged;
            //4.设置 该对象 的 uName属性 为 修改状态，同时 entry.State 被修改为 Modified 状态
            entry.Property("ShiName").IsModified = true;

            //3.重新保存到数据库 -- ef 上下文 会 根据 实体对象的 状态 ，根据 entry.State =Modified 的值 生成 对应的 update sql 语句
            db.SaveChanges();
            Console.WriteLine("修改成功：");
            Console.WriteLine(usr.ToString());
        }
        #endregion

  四删除：

    #region 删除
        /// <summary>
        /// 
        /// </summary>
        static void Delete()
        {
            AdvertisingArea adv = new AdvertisingArea() { Id = 22 };
            db.AdvertisingArea.Attach(adv);
            db.AdvertisingArea.Remove(adv);
            db.SaveChanges();
            Console.WriteLine("删除成功");
        }
        #endregion

五 批处理（1）：可以将所有的操作（增加、修改、删除）添加到集合中，只需SaveChange（）一次，即可秩序全部操作

     #region  批处理 -- 上下文 SaveChanges 方法 的 好处！！！！
        /// <summary>
        /// 批处理 -- 上下文 SaveChanges 方法 的 好处！！！！
        /// </summary>
        static void SaveBatched()
        {


            //新增数据
            //创建实体对象
            AdvertisingArea advEF1 = new AdvertisingArea()
            {
                QuName = "我是新增1",
                ShengId = 2,
                ShiId = 2,
                ShengName = "22222",
                ShiName = "23333",
                QuId = 2232,
            }; ;
            db.AdvertisingArea.Add(advEF1);
            //创建实体对象
            AdvertisingArea advEF2 = new AdvertisingArea()
            {
                QuName = "我是新增2",
                ShengId = 2,
                ShiId = 2,
                ShengName = "22222",
                ShiName = "23333",
                QuId = 2232,
            }; ;
            db.AdvertisingArea.Add(advEF2);

            //修改数据
            AdvertisingArea usr = new AdvertisingArea() { Id = 24, QuName = "又黑了~~~" };
            DbEntityEntry<AdvertisingArea> entry = db.Entry<AdvertisingArea>(usr);
            entry.State = System.Data.EntityState.Unchanged;
            entry.Property("QuName").IsModified = true;

            //删除数据
            AdvertisingArea u = new AdvertisingArea() { Id = 22 };
            //附加到 EF中
            db.AdvertisingArea.Attach(u);
            //标记为删除 注意：此方法 就是 起到了 标记 当前对象  为 删除状态 ！
            db.AdvertisingArea.Remove(u);

            db.SaveChanges();
            Console.WriteLine("批处理 完成~~~~~~~~~~~~！");
        }
        #endregion

  批处理（2）循环添加：

  #region  批处理 -- 一次新增 50条数据 -void BatcheAdd()
        /// <summary>
        /// 批处理 -- 一次新增 50条数据
        /// </summary>
        static void BatcheAdd()
        {
            for (int i = 0; i < 50; i++)
            {
                AdvertisingArea uObj = new AdvertisingArea()
                {
                    QuName = "我是新增" + i,
                    ShengId = 2,
                    ShiId = 2,
                    ShengName = "22222",
                    ShiName = "23333",
                    QuId = 2232,
                };
                db.AdvertisingArea.Add(uObj);
            }
            db.SaveChanges();
        }
        #endregion

附：底层封装

public class CommonUser
    {
        EFModel.AdvEFEntities db = new EFModel.AdvEFEntities();
        #region 新增实体

        public int Add(EFModel.CommonUser area)
        {
            db.CommonUser.Add(area);
            return db.SaveChanges();
        }
        #endregion


        #region  根据 用户 id 删除 +int Del(int uId)
        /// <summary>
        /// 根据 用户 id 删除
        /// </summary>
        /// <param name="uId"></param>
        /// <returns></returns>
        public int Del(Guid userId)
        {
            EFModel.CommonUser usr = new EFModel.CommonUser() { userId  = userId };
            db.CommonUser.Attach(usr);
            db.CommonUser.Remove(usr);
            return db.SaveChanges();
        }
        #endregion

        #region  根据条件删除 +int DelBy(Expression<Func<P05MODEL.User, bool>> delWhere)
        /// <summary>
        /// 根据条件删除
        /// </summary>
        /// <param name="delWhere"></param>
        /// <returns></returns>
        public int DelBy(Expression<Func<EFModel.CommonUser, bool>> delWhere)
        {
            List<EFModel.CommonUser> listDeleting = db.CommonUser.Where(delWhere).ToList();
            listDeleting.ForEach(u => db.CommonUser.Remove(u));
            return db.SaveChanges();
        }
        #endregion

        #region 修改 +int Modify(EFModel.CommonUser model, params string[] proNames)
        /// <summary>
        ///  修改，如：
        ///EFModel.CommonUser u = newEFModel.CommonUser() { uId = 1, uLoginName = "asdfasdf" };
        /// this.Modify(u, "uLoginName");
        /// </summary>
        /// <param name="model">要修改的实体对象</param>
        /// <param name="proNames">要修改的 属性 名称</param>
        /// <returns></returns>
        public int Modify(EFModel.CommonUser model, params string[] proNames)
        {
            DbEntityEntry entry = db.Entry<EFModel.CommonUser>(model);
            entry.State = System.Data.EntityState.Unchanged;
            foreach (string proName in proNames)
            {
                entry.Property(proName).IsModified = true;
            }
            return db.SaveChanges();
        }
        #endregion

        #region  根据条件查询 +List<EFModel.CommonUser> GetListBy(Expression<Func<EFModel.CommonUser,bool>> whereLambda)
        /// <summary>
        ///  根据条件查询 +List<EFModel.CommonUser> GetListBy(Expression<Func<EFModel.CommonUser,bool>> whereLambda)
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public List<EFModel.CommonUser> GetListBy(Expression<Func<EFModel.CommonUser, bool>> whereLambda)
        {
            return db.CommonUser.Where(whereLambda).ToList();
        }
        #endregion

        #region  根据条件 排序 和查询 + List<EFModel.CommonUser> GetListBy<TKey>
        /// <summary>
        ///  根据条件 排序 和查询
        /// </summary>
        /// <typeparam name="TKey">排序字段类型</typeparam>
        /// <param name="whereLambda">查询条件 lambda表达式</param>
        /// <param name="orderLambda">排序条件 lambda表达式</param>
        /// <returns></returns>
        public List<EFModel.CommonUser> GetListBy<TKey>(Expression<Func<EFModel.CommonUser, bool>> whereLambda, Expression<Func<EFModel.CommonUser, TKey>> orderLambda, bool desc)
        {
            if (desc)
            {
                return db.CommonUser.Where(whereLambda).OrderByDescending(orderLambda).ToList();
            }
            else
            {
                return db.CommonUser.Where(whereLambda).OrderBy(orderLambda).ToList();
            }
        }
        #endregion

        #region 分页查询 + List<EFModel.CommonUser> GetPagedList<TKey>
        /// <summary>
        ///  分页查询 + List<EFModel.CommonUser> GetPagedList<TKey>
        /// </summary>
        /// <param name="pageIndex">页码</param>
        /// <param name="pageSize">页容量</param>
        /// <param name="whereLambda">条件 lambda表达式</param>
        /// <param name="orderBy">排序 lambda表达式</param>
        /// <returns></returns>
        public List<EFModel.CommonUser> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<EFModel.CommonUser, bool>> whereLambda, Expression<Func<EFModel.CommonUser, TKey>> orderBy, bool desc)
        {
            if (desc)
            {
                return db.CommonUser.Where(whereLambda).OrderByDescending(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
            else
            {
                return db.CommonUser.Where(whereLambda).OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }

        }
        #endregion
    }