EF简单增删改查

一. 主要内容

1. 数据持久层框架：EF，NHibernate，ibaties(半开放的)。

2. 对象关系映射。

3. 生成外键对象。

4. T4模板。（VS里面需要装T4 Editor插件。）

5. EF上下文(EF容器)->.Context.cs。

6. EF简单的增删改查。

查询：利用部分类的特性重写方法来进行方法的扩展。

修改（SQL Serrver Profiler跟踪）：

先查询，再修改，再保存更改。

7. 延迟加载（延时查询、按需加载）和即时查询。

延迟加载的用途一：

SQL语句条件不确定，所以不能立即进行查询，延迟加载以确定所有条件完成，等开始用的时候才开始查询。

延迟加载的用途二（外键延迟）：

对于外键实体属性的延迟加载。

按需加载的缺点：

每次调用外键实体时，都会去查询数据库（EF小优化:相同的外键实体只查询一次），这时候用即使加载比较好。

8. 延迟加载二视频里面的：数据库改变，则EF实体不会对应改变，可以选择从数据库更新模型。

9. EF的连接查询

include(“User”)，通过include方法，可以告诉EF连接查询哪个外键属性。

10. EF容器（EF数据上下文）

       修改时，不用Attach方式，使用Entry方式。

11. 批处理

12. MODELFirst（实体优先）

13.  EF补充：Select方法能自动生成inner join语句。

二. 源代码

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

namespace EFTest
{
    class Program
    {
        static LeaveWordBoardEntities db = new LeaveWordBoardEntities();
        static void Main(string[] args)
        {
            Querry();
        }

        static Program()
        {
            //取消自动验证所跟踪的实体
            db.Configuration.ValidateOnSaveEnabled = false;
        }

        #region 1.0 新增
        /// <summary>
        /// 新增
        /// </summary>
        static void Add()
        {
            User uObj = new User()
            {
                uName = "HUOAA11",
                uLoginName = "a11",
                uPwd = "a11",
                uIsDel = false,
                uAddTime = DateTime.Now
            };
            //两种不同的新增方式：本质上都是把该对象标记为新增，让EF上下文来执行新增操作。
            //db.Users.Add(uObj);
            DbEntityEntry<User> entry = db.Entry<User>(uObj);
            entry.State = EntityState.Added;
            db.SaveChanges();
            Console.WriteLine("新增成功！");
        }
        #endregion

        #region 2.0 简单查询
        /// <summary>
        /// 简单查询
        /// </summary>
        static void Querry()
        {
            //1.1 延时查询一
            //DbQuery<User> i = db.Users.Where(u => u.uLoginName == "HUOTENG").OrderBy(u => u.uId) as DbQuery<User>;
            //User user01 = i.FirstOrDefault();
            //Console.WriteLine(user01.uName);

            //1.2 延时查询二：针对于外键实体
            //对于外键属性而言，EF会用这个外键属性时才去查询对应的表。
            //IQueryable<UsersAddress> addrs = db.UsersAddresses.Where(a=>a.udUId==2);//真实返回的DBQuery对象，以接口方式返回
            ////a. 此时只查询了地址表
            //UsersAddress addr01 = addrs.FirstOrDefault();
            ////b. 查询地址对应的用户表
            //Console.WriteLine(addr01.User.uName); 
            //c. 按需加载的缺点:会为每次调用外键实体时，都会去查询数据库。
            //IQueryable<UsersAddress> addrs = db.UsersAddresses;
            //foreach (UsersAddress add in addrs)
            //{
            //    Console.WriteLine(add.udAddress+":userName="+add.User.uName);
            //}
            //1.3 连接查询，生成innner join
            //IQueryable<UsersAddress> addrs = db.UsersAddresses.Include("User");
            //foreach (UsersAddress add in addrs)
            //{
            //    Console.WriteLine(add.udAddress + ":userName=" + add.User.uName);
            //}
            //IQueryable<Msg> msgs = db.Msgs.Include("User").Include("User1");
            //foreach (Msg msg in msgs)
            //{
            //    Console.WriteLine(msg.mId + "," + msg.User.uName + "," + msg.User1.uName + "," + msg.mMsg);
            //}
            //1.4 另一种方式的连接查询Select
            var addrs = db.UsersAddresses.Where(a => a.udUId == 1).Select(a => new { aId = a.udUId, aAddress = a.udAddress, aUserName = a.User.uName }).ToList();


            //2. 变相的即时查询
            //List<User> list = db.Users.Where(u => u.uName == "HUOAA").ToList();
            //list.ForEach(u => Console.WriteLine(u.ToString()));
        }
        #endregion

        #region 3.0 先查询再修改
        /// <summary>
        /// 先查询再修改
        /// </summary>
        static void Edit()
        {
            User user = db.Users.Where(u => u.uId == 3).FirstOrDefault();
            user.uName = "nihaoa2";
            db.SaveChanges();
            Console.WriteLine("修改成功！");
        }
        #endregion

        #region 4.0 直接修改
        /// <summary>
        /// 直接修改
        /// </summary>
        static void Edit2()
        {
            ////1. 查询出一个要修改的对象，此时返回的是一个User类的代理类对象
            //User user = db.Users.Where(u => u.uId == 2).FirstOrDefault();
            //Console.WriteLine("修改前："+user.ToString());
            ////2. 如果被修改，会在EF上下文容器中标记该属性为已修改
            //user.uName = "刘德华";
            ////3. EF上下文进行检查，找到标记修改的属性，生成对应的UPDATE语句进行修改
            //db.SaveChanges();
            //Console.WriteLine("修改后："+user.ToString());

            //Entry方式修改
            User user = new User() { uId = 2, uName = "小白", uLoginName = "xiaobai", uPwd = "13", uAddTime = DateTime.Now, uIsDel = false };
            DbEntityEntry<User> entry = db.Entry<User>(user);
            entry.State = EntityState.Unchanged;
            entry.Property("uName").IsModified = true;
            db.SaveChanges();
            Console.WriteLine("修改成功！");
        }
        #endregion

        #region 5.0 删除
        /// <summary>
        /// 删除
        /// </summary>
        static void Del()
        {
            User u = new User() { uId = 4 };
            db.Users.Attach(u);
            db.Users.Remove(u);
            /*
             * 也可以用Entry来附加和修改
             * DbEntityEntry<User> entry = db.Entry<User>(u);
             * entry.State = EntityState.Deleted;
             */
            db.SaveChanges();
        }
        #endregion

        #region 6.0 批处理
        /// <summary>
        /// 6.0 批处理
        /// </summary>
        static void SaveBatched()
        {
            //6.1 新增
            //User u1 = new User()
            //{
            //    uName = "asd",
            //    uLoginName = "c",
            //    uPwd = "asdf",
            //    uIsDel = false,
            //    uAddTime = DateTime.Now
            //};
            //db.Users.Add(u1);

            //6.2 修改
            User u2 = new User() { uId = 8, uName = "小黑" };
            DbEntityEntry<User> entry = db.Entry<User>(u2);
            entry.State = EntityState.Unchanged;
            entry.Property("uName").IsModified = true;

            //6.3 删除
            //User u3 = new User() { uId=7};
            //db.Users.Attach(u3);
            //db.Users.Remove(u3);

            //6.4 进行统一的批处理
            db.SaveChanges();
            Console.WriteLine("批处理完成！");
        }
        #endregion

        #region 7.0 批处理添加大量数据
        /// <summary>
        /// 批处理添加大量数据
        /// </summary>
        static void BatchAdd()
        {
            for (int i = 0; i < 50; i++)
            {
                User u = new User()
                {
                    uName = "qwer" + i,
                    uLoginName = "qwer" + i,
                    uPwd = "qwer" + i,
                    uIsDel = true,
                    uAddTime = DateTime.Now
                };
                db.Users.Add(u);
            }
            db.SaveChanges();
            Console.WriteLine("批处理完成！~");
        }
        #endregion
    }
}