Linq to SQL 的增刪改查操作(附幫助類)

      Linq，全稱Language Integrated Query，作為C#3.0新語法，是C#語言的一個擴展，可以將數據查詢直接集成到編程語言本身中。 Linq表達式和SQL語句差不多，說白了就是顛倒sql語法， from where select ...，從from開始，以select/group by 結束，輸出一個IEnumerable<T>或 IQueryable<T>的集合。世間萬物皆系於一箭之上，存在即合理，技術是進步的，還可使用標准化查詢運算符（SQO），繼承自IEnuberable<T>接口，提供了 篩選、投影、聚合、排序等功能的方法，缺點就是語句太多龐大復雜。優點使用便捷，有即時加載(FindAll)和延時加載（Where）

      EF(Entity Framework)Ado.NET中面向開發數據的一種技術，有Code First、Model First、Database First，是微軟的一個ORM框架。

      Lambda表達式的本質就是匿名函數，可以包含表達式和語句，也可以用於創建委托或表達式樹類型，運算符為“=>”，讀作 goes to，借用MVC企業級實戰書中一圖

            new Func<string, int>(delegate (string str) { return str.Length; });

            (delegate (string str) { return str.Length; });    //匿名方法

            (string str) => { return str.Length; };  //Lambda語句

            (string str) => str.Length;  //Lambda表達式

            (str) => str.Lenth;     //省略類型，讓IDE去判斷

            str => str.Lenth;       //去掉括號

 Linq操作的是數據對象，所以需要先建立一個實體對象模型，操作的表如下

USE [IBBC]
GO
CREATE TABLE [Table_1](
IDD INT PRIMARY KEY NOT NULL,
Nnmae VARCHAR(15) NULL    
)

INSERT [dbo].[Table_1] ([IDD], [Nnmae]) VALUES (100, N'清高祖'),(102, N'清高宗'),
(103, N'清太祖'),(104, N'Test1'),
(105, N'Test2'),(106, N'Test3'),
(107, N'Test4'),(108, N'Test5')

查詢：

public void Dbquery(int id) 
{
   IBBCEntities db = new IBBCEntities();
   var request = from d in db.Table_1
          where d.IDD == id
          select new { d.IDD, d.Nnmae };
         
    foreach (var item in request)
    {
      Console.WriteLine("查詢語法： " + item);
    }

   var request1 = db.Table_1.SingleOrDefault(b => b.IDD == id);
   Console.WriteLine("（SQO）方法語法： " +request1.IDD+" "+request1.Nnmae);
           
   Console.ReadKey();
}

添加：

//添加：
  var add1 = db.Table_1.SingleOrDefault(c=>c.IDD==1010);
   if (add1.IDD.Tostring()==null)
    {
       Table_1 tb = new Table_1
        {
           IDD = 1010,
           Nnmae = "張三豐"
         };
        db.Table_1.Add(tb);
        db.SaveChanges();
     }
     
(PS:add1.IDD為Int類型，所以永遠不會等於null，故取其ToString（），下同)) 

修改：

//修改
var update1 = db.Table_1.SingleOrDefault(c => c.IDD == 1010);
if (update1.IDD.Tostring()!=null) 
{ 
  update1.Nnmae = "張君寶";
  db.SaveChanges(); 
}

刪除：

//刪除
 var delete1 = db.Table_1.SingleOrDefault(c=>c.IDD==1010);
 if (delete1.IDD.Tostring()!=null)
 {
  db.Table_1.Remove(delete1);
  db.SaveChanges(); 
 }

 當然，在選擇EF 作為數據ORM時，和以前的SQL 同樣需要封裝一個幫助類，便於對數據庫表的操作，這里網上很多，隨手附加一個通用類，當然也可以根據自己的特定業務進行自我拓展。

    /// <summary>
    /// 數據庫操作類
    /// </summary>
    public class BaseDAL<T> where T : class
    {
        public StudentQualityEntities db = new StudentQualityEntities();

        /// <summary>
        /// 添加實體
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Add(T model)
        {
            try
            {
                db.Set<T>().Add(model);
                return db.SaveChanges();
            }
            catch (Exception ex)
            {
                LogHelper.LogQueue.Enqueue(ex.Message + "--" + ex.StackTrace);
                return -1;
            }
        }

        /// <summary>
        /// 批量添加數據
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listModel"></param>
        /// <returns></returns>
        public int Add(List<T> listModel)
        {
            listModel.ForEach(i =>
            {
                db.Set<T>().Add(i);
            });
            return db.SaveChanges();
        }

        /// <summary>
        /// 刪除數據  實體需包含主鍵Id
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Del(T model)
        {
            try
            {
                db.Set<T>().Attach(model);
                db.Set<T>().Remove(model);
                return db.SaveChanges();
            }
            catch (Exception ex)
            {
                LogHelper.LogQueue.Enqueue(ex.Message + "--" + ex.StackTrace);
                return -1;
            }


        }

        /// <summary>
        /// 刪除多筆數據-條件
        /// </summary>
        /// <param name="delWhere"></param>
        /// <returns></returns>
        public int DelMulBy(Expression<Func<T, bool>> delWhere)
        {
            try
            {
                //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();
            }
            catch (Exception ex)
            {
                LogHelper.LogQueue.Enqueue(ex.Message + "--" + ex.StackTrace);
                return -1;
            }


        }

        /// <summary>
        /// 刪除多筆數據 -集合
        /// </summary>
        /// <param name="lis"></param>
        /// <returns></returns>
        public int DelMulList(IQueryable<T> lis)
        {
            try
            {
                foreach (var item in lis)
                {
                    db.Set<T>().Attach(item);//先附加到 EF容器
                    db.Set<T>().Remove(item);//標識為 刪除 狀態
                }
                return db.SaveChanges();

            }
            catch (Exception ex)
            {
                LogHelper.LogQueue.Enqueue(ex.Message + "---" + ex.StackTrace);
                return -1;
            }
        }

        /// <summary>
        /// 查詢一筆數據
        /// </summary>
        /// <param name="lambda"></param>
        /// <returns></returns>
        public T GetOneEntity(Expression<Func<T, bool>> lambda)
        {
            return db.Set<T>().Where(lambda).FirstOrDefault();
        }


        /// <summary>
        /// 查詢多筆數據+條件
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public IQueryable<T> GetListBy(Expression<Func<T, bool>> lambda)
        {
            return db.Set<T>().Where(lambda);
        }

        /// <summary>
        /// 查詢多筆數據 條件+排序
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="orderLambda"></param>
        /// <returns></returns>
        public IQueryable<T> GetListBy<TKey>(Expression<Func<T, bool>> lambda, Expression<Func<T, TKey>> orderLambda, int count)
        {
            if (count == 0)
            {
                return db.Set<T>().Where(lambda).OrderBy(orderLambda);
            }
            return db.Set<T>().Where(lambda).Take(count).OrderBy(orderLambda);
        }

        /// <summary>
        /// 修改一筆數據
        /// </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.Entity.EntityState.Unchanged;
            //4.3循環 被修改的屬性名 數組
            foreach (string proName in proNames)
            {
                //4.4將每個 被修改的屬性的狀態 設置為已修改狀態;后面生成update語句時，就只為已修改的屬性 更新
                entry.Property(proName).IsModified = true;
            }
            //4.4一次性 生成sql語句到數據庫執行
            return db.SaveChanges();
        }


        /// <summary>
        /// 批量修改
        /// </summary>
        /// <param name="model">要修改的實體對象</param>
        /// <param name="whereLambda">查詢條件</param>
        /// <param name="modifiedProNames">要修改的 屬性 名稱</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();
        }

    }

 

 

 

 

權當做學習記錄

        --市人皆大笑，舉手揶揄之