這裡我接上講Entity Framework入門。從網上下載Northwind資料庫，新建一個控制檯程式，然後重新新增一個ado.net實體資料模型。

EF中操作資料庫的"閘道器"(操作上下文)

DBContext封裝 .NET Framework 和資料庫之間的連線。此類用作“建立”、“讀取”、“更新”和“刪除”操作的閘道器。
DBContext 類為主類，用於與作為物件（這些物件為 EDM 中定義的實體型別的例項）的資料進行互動。
DBContext 類的例項封裝以下內容：

• 到資料庫的連線，以 EntityConnection 物件的形式封裝。
• 描述該模型的元資料，以 MetadataWorkspace 物件的形式封裝
• 用於管理快取中持久儲存的物件的 ObjectStateManager 物件

一、新增

        #region 新增 1.0
        static int Add()
        {
            Customers _Customers = new Customers {CustomerID="zhang",Address="洛陽西街",City="洛陽",Phone="1314520",
            CompanyName="微軟",ContactName="李四" };
            //方法一
            
 
//db.Customers.Add(_Customers);

            //方法二
            DbEntityEntry<Customers> entry = db.Entry<Customers>(_Customers);
            entry.State = System.Data.Entity.EntityState.Added;

           return db.SaveChanges();
        }
        #endregion

二、簡單查詢 延時載入

為了檢視延時載入，要使用SqlProfiler跟蹤sql語句

EF生成sql語句傳送給資料庫執行，我們可以使用sqlserver的跟蹤監測工具檢視。（可監測sql語句、CPU佔用、執行時間等）

【延時載入】 看成兩種：

1、 EF本身查詢方法 返回的都是 IQueryable介面，此時並未查詢資料庫；只有當呼叫介面方法 獲取 資料時，才會查詢資料庫

2、 【延時載入】，本質原因之一：當前可能通過多個SQO方法 來組合 查詢條件，那麼每個方法 都只是新增一個查詢條件而已，無法確定本次查詢條件 是否 已經新增結束  所以，沒有辦法在每個SQO方法的時候確定SQL語句是什麼，只能返回一個 包含了所有新增的條件的 DBQuery 物件，  當使用這個 DBQuery物件 的時候，才根據所有條件 生成 sql語句，查詢資料庫

        #region 2.1 簡單查詢 延遲載入 -void QueryDelay_01()
        static void QueryDelay_01()
        {
            DbQuery<Customers> dbQuery = db.Customers.Where(u => u.ContactName == "張學友").OrderBy(u => u.ContactName).Take(2) 

as System.Data.Entity.Infrastructure.DbQuery<Customers>;
            //獲得 延遲查詢物件後，呼叫物件的 獲取第一個資料方法，此時，【就會根據之前的條件】，生成sql語句，查詢資料庫了~~！
            Customers usr01 = dbQuery.FirstOrDefault();// ToList()......
            Console.WriteLine(usr01.ContactName);
        }

        //2.1.2【延遲載入】- 針對於 外來鍵實體 的延遲(按需載入)！
        //                  本質原因之二：對於外來鍵屬性而言，EF會在用到這個外來鍵屬性的時候才去查詢 對應的 表。
        static void QueryDelay_02()
        {
            IQueryable<Orders> _Orders = db.Orders.Where(a => a.CustomerID == "TOMSP");//真實返回的 DbQuery 物件，以介面方式返回
            //a.此時只查詢了 地址表
            Orders order = _Orders.FirstOrDefault();
            //b.當訪問 地址物件 裡的 外來鍵實體時，EF會查詢 地址對應 的使用者表;查詢到之後，將資料 裝入 這個外來鍵實體
            Console.WriteLine(order.Customers.ContactName);

            //c.【延遲載入】按需載入 的缺點：每次呼叫外來鍵實體時，都會去查詢資料庫（EF有小優化：相同的外來鍵實體只查一次）
            IQueryable<Orders> orderList = db.Orders;
            foreach (Orders o in orderList)
            {
                Console.WriteLine(o.OrderID + ":ContactName=" + o.Customers.ContactName);
            }
        }
        #endregion

        #region 2.2 根據條件 排序 和查詢 + List<Customers> GetListBy<TKey>
        /// <summary>
        /// 2.2 根據條件 排序 和查詢
        /// </summary>
        /// <typeparam name="TKey">排序欄位型別</typeparam>
        /// <param name="whereLambda">查詢條件 lambda表示式</param>
        /// <param name="orderLambda">排序條件 lambda表示式</param>
        /// <returns></returns>
        public List<Customers> GetListBy<TKey>(Expression<Func<Customers, bool>> whereLambda, Expression<Func<Customers, TKey>> orderLambda)
        {
            return db.Customers.Where(whereLambda).OrderBy(orderLambda).ToList();
        }
        #endregion

        #region 2.3 分頁查詢 + List<P05MODEL.User> GetPagedList<TKey>
        /// <summary>
        /// 2.3 分頁查詢 + List<Customers> 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<Customers> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<Customers, bool>> whereLambda,
 Expression<Func<Customers, TKey>> orderBy)
        {
            // 分頁 一定注意： Skip 之前一定要 OrderBy
            return db.Customers.Where(whereLambda).OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
        }
        #endregion

三、修改

        #region 3.0 官方推薦的 修改方式（先查詢，再修改）
        /// <summary>
        /// 3.0 官方推薦的 修改方式（先查詢，再修改）
        /// </summary>
        static void Edit()
        {
            //1.查詢出一個 要修改的物件 -- 注意：此時返回的 是 一個 Customers類的 代理類物件（包裝類物件）
            Customers _Customers = db.Customers.Where(u => u.CustomerID == "zhang").FirstOrDefault();
            Console.WriteLine("修改前：" + _Customers.ContactName);
            //2.修改內容 -- 注意：此時其實操作的 是 代理類物件 的屬性，這些屬性，會將值設定給內部的 Customers物件對應的屬性，同時標記此屬性為已修改狀態
            _Customers.ContactName = "劉德華";
            //3.重新儲存到資料庫 -- 注意：此時 ef上下文，會檢查容器內部 所有的物件，找到標記為修改的物件，然後找到標記為修改的物件屬性，生成對應的update語句執行！
            db.SaveChanges();
            Console.WriteLine("修改成功：");
            Console.WriteLine(_Customers.ContactName);
        }
        #endregion

        #region 3.1 自己優化的 修改方式（建立物件，直接修改）
        /// <summary>
        /// 3.1 自己優化的 修改方式（建立物件，直接修改）
        /// </summary>
        static void Edit2()
        {
            //1.查詢出一個 要修改的物件
            Customers _Customers = new Customers() { CustomerID = "zhang", Address = "洛陽西街", City = "洛陽", Phone = "1314520", 
CompanyName = "微軟", ContactName = "張學友" };
            //2.將 物件 加入 EF容器,並獲取 當前實體物件 的 狀態管理物件
            DbEntityEntry<Customers> entry = db.Entry<Customers>(_Customers);
            //3.設定 該物件 為被修改過
            entry.State = System.Data.EntityState.Unchanged;
            //4.設定 該物件 的 ContactName屬性 為 修改狀態，同時 entry.State 被修改為 Modified 狀態
            entry.Property("ContactName").IsModified = true;

            //var u = db.Customers.Attach(_Customers);
            //u.ContactName = "郭富城";

            //3.重新儲存到資料庫 -- ef 上下文 會 根據 實體物件的 狀態 ，根據 entry.State =Modified 的值 生成 對應的 update sql 語句
            db.SaveChanges();
            Console.WriteLine("修改成功：");
            Console.WriteLine(_Customers.ContactName);
        }
        #endregion

四、刪除

        #region 4.0 刪除 -void Delete()
        /// <summary>
        /// 4.0 刪除
        /// </summary>
        static void Delete()
        {
            //4.1建立要刪除的 物件
            Customers u = new Customers() { CustomerID = "zhang" };
            //4.2附加到 EF中
            db.Customers.Attach(u);
            //4.3標記為刪除 注意：此方法 就是 起到了 標記 當前物件  為 刪除狀態 ！
            db.Customers.Remove(u);

            /*
                也可以使用 Entry 來附加和 修改
                DbEntityEntry<Customers> entry = db.Entry<Customers>(u);
                entry.State = System.Data.EntityState.Deleted;
             */

            //4.4執行刪除sql
            db.SaveChanges();
            Console.WriteLine("刪除成功~~~");
        }
        #endregion

五、批處理

        #region 5.0 批處理 -- 上下文 SaveChanges 方法 的 好處！！！！
        /// <summary>
        /// 批處理 -- 上下文 SaveChanges 方法 的 好處！！！！
        /// </summary>
        static void SaveBatched()
        {
            //5.1新增資料
            Customers _Customers = new Customers { CustomerID = "zou", Address = "洛陽西街", City = "洛陽", Phone = "1314520",
 CompanyName = "微軟", ContactName = "鄒玉傑" };
            db.Customers.Add(_Customers);

            //5.2新增第二個資料
            Customers _Customers2 = new Customers { CustomerID = "zhao", Address = "洛陽西街", City = "洛陽", Phone = "1314520", 
CompanyName = "微軟", ContactName = "趙匡胤" };
            db.Customers.Add(_Customers2);

            //5.3修改資料
            Customers usr = new Customers() { CustomerID = "zhao", ContactName = "趙牧" };
            DbEntityEntry<Customers> entry = db.Entry<Customers>(usr);
            entry.State = System.Data.EntityState.Unchanged;
            entry.Property("ContactName").IsModified = true;

            //5.4刪除資料
            Customers u = new Customers() { CustomerID = "zou" };
            //4.2附加到 EF中
            db.Customers.Attach(u);
            //4.3標記為刪除 注意：此方法 就是 起到了 標記 當前物件  為 刪除狀態 ！
            db.Customers.Remove(u);

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

        #region 5.1 批處理 -- 一次新增 50條資料 -void BatcheAdd()
        /// <summary>
        /// 5.1 批處理 -- 一次新增 50條資料
        /// </summary>
        static void BatcheAdd()
        {
            for (int i = 0; i < 50; i++)
            {
                Customers _Customers = new Customers { CustomerID = "zou" + i, Address = "洛陽西街", City = "洛陽", Phone = "1314520", 
CompanyName = "微軟", ContactName = "鄒玉傑" + i };
                db.Customers.Add(_Customers);
            }
            db.SaveChanges();
        }
        #endregion

 通用資料庫操作基類

我們看到這些資料庫基本操作CRUD等，可以通過泛型提取出來放到父類裡面，不需要每個不同的資料庫操作類中都寫一遍。

    public class BaseDAL<T> where T:class,new()
    {
        /// <summary>
        /// 資料上下文物件
        /// </summary>
        P05MODEL.LeaveWordBoradEntities db = new P05MODEL.LeaveWordBoradEntities();

        #region 1.0 新增 實體 +int Add(T model)
        /// <summary>
        /// 新增 實體
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Add(T model)
        {
            db.Set<T>().Add(model);
            return db.SaveChanges();//儲存成功後，會將自增的id設定給 model的 主鍵屬性，並返回受影響行數
        }
        #endregion

        #region 2.0 根據 id 刪除 +int Del(T model)
        /// <summary>
        /// 根據 id 刪除
        /// </summary>
        /// <param name="model">包含要刪除id的物件</param>
        /// <returns></returns>
        public int Del(T model)
        {
            db.Set<T>().Attach(model);
            db.Set<T>().Remove(model);
            return db.SaveChanges();
        }
        #endregion

        #region 3.0 根據條件刪除 +int DelBy(Expression<Func<T, bool>> delWhere)
        /// <summary>
        /// 3.0 根據條件刪除
        /// </summary>
        /// <param name="delWhere"></param>
        /// <returns></returns>
        public int DelBy(Expression<Func<T, bool>> delWhere)
        {
            //3.1查詢要刪除的資料
            List<T> listDeleting = db.Set<T>().Where(delWhere).ToList();
            //3.2將要刪除的資料 用刪除方法新增到 EF 容器中
            listDeleting.ForEach(u =>
            {
                db.Set<T>().Attach(u);//先附加到 EF容器
                db.Set<T>().Remove(u);//標識為 刪除 狀態
            });
            //3.3一次性 生成sql語句到資料庫執行刪除
            return db.SaveChanges();
        }
        #endregion

        #region 4.0 修改 +int Modify(T model, params string[] proNames)
        /// <summary>
        /// 4.0 修改，如：
        /// T u = new T() { uId = 1, uLoginName = "asdfasdf" };
        /// this.Modify(u, "uLoginName");
        /// </summary>
        /// <param name="model">要修改的實體物件</param>
        /// <param name="proNames">要修改的 屬性 名稱</param>
        /// <returns></returns>
        public int Modify(T model, params string[] proNames)
        {
            //4.1將 物件 新增到 EF中
            DbEntityEntry entry = db.Entry<T>(model);
            //4.2先設定 物件的包裝 狀態為 Unchanged
            entry.State = System.Data.EntityState.Unchanged;
            //4.3迴圈 被修改的屬性名 陣列
            foreach (string proName in proNames)
            {
                //4.4將每個 被修改的屬性的狀態 設定為已修改狀態;後面生成update語句時，就只為已修改的屬性 更新
                entry.Property(proName).IsModified = true;
            }
            //4.4一次性 生成sql語句到資料庫執行
            return db.SaveChanges();
        }
        #endregion

        #region 4.0 批量修改 +int Modify(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedProNames)
        /// <summary>
        /// 4.0 批量修改
        /// </summary>
        /// <param name="model">要修改的實體物件</param>
        /// <param name="whereLambda">查詢條件</param>
        /// <param name="proNames">要修改的 屬性 名稱</param>
        /// <returns></returns>
        public int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedProNames)
        {
            //4.1查詢要修改的資料
            List<T> listModifing = db.Set<T>().Where(whereLambda).ToList();

            //獲取 實體類 型別物件
            Type t = typeof(T); // model.GetType();
            //獲取 實體類 所有的 公有屬性
            List<PropertyInfo> proInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
            //建立 實體屬性 字典集合
            Dictionary<string, PropertyInfo> dictPros = new Dictionary<string, PropertyInfo>();
            //將 實體屬性 中要修改的屬性名 新增到 字典集合中 鍵：屬性名  值：屬性物件
            proInfos.ForEach(p =>
            {
                if (modifiedProNames.Contains(p.Name))
                {
                    dictPros.Add(p.Name, p);
                }
            });

            //4.3迴圈 要修改的屬性名
            foreach (string proName in modifiedProNames)
            {
                //判斷 要修改的屬性名是否在 實體類的屬性集合中存在
                if (dictPros.ContainsKey(proName))
                {
                    //如果存在，則取出要修改的 屬性物件
                    PropertyInfo proInfo = dictPros[proName];
                    //取出 要修改的值
                    object newValue = proInfo.GetValue(model, null); //object newValue = model.uName;

                    //4.4批量設定 要修改 物件的 屬性
                    foreach (T usrO in listModifing)
                    {
                        //為 要修改的物件 的 要修改的屬性 設定新的值
                        proInfo.SetValue(usrO, newValue, null); //usrO.uName = newValue;
                    }
                }
            }
            //4.4一次性 生成sql語句到資料庫執行
            return db.SaveChanges();
        }
        #endregion

        #region 5.0 根據條件查詢 +List<T> GetListBy(Expression<Func<T,bool>> whereLambda)
        /// <summary>
        /// 5.0 根據條件查詢 +List<T> GetListBy(Expression<Func<T,bool>> whereLambda)
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public List<T> GetListBy(Expression<Func<T, bool>> whereLambda)
        {
            return db.Set<T>().Where(whereLambda).ToList();
        }
        #endregion

        #region 5.1 根據條件 排序 和查詢 + List<T> GetListBy<TKey>
        /// <summary>
        /// 5.1 根據條件 排序 和查詢
        /// </summary>
        /// <typeparam name="TKey">排序欄位型別</typeparam>
        /// <param name="whereLambda">查詢條件 lambda表示式</param>
        /// <param name="orderLambda">排序條件 lambda表示式</param>
        /// <returns></returns>
        public List<T> GetListBy<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda)
        {
            return db.Set<T>().Where(whereLambda).OrderBy(orderLambda).ToList();
        }
        #endregion

        #region 6.0 分頁查詢 + List<T> GetPagedList<TKey>
        /// <summary>
        /// 6.0 分頁查詢 + List<T> 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<T> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderBy)
        {
            // 分頁 一定注意： Skip 之前一定要 OrderBy
            return db.Set<T>().Where(whereLambda).OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
        }
        #endregion
    }