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();
        }

    }

权当做学习记录

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