Lambda表达式与LINQ
C#LINQ和Lambda表达式详解
C#LINQ和Lambda表达式详解(1) 简单的查询语句1 Linq语法:2var data=from a in db.Areas select a ;3 Lamda语法:4var data=db.Areas;5 sql语法:6string sqlStr=" SELECT * FROM Areas ";(2) 简单的WHERE语句1 Linq语法:2var data=from a in db.orderInfo where a.orderId > 20select a ;3 Lamda语法:4var data=db.orderInfo.Where( t=>t.orderId > 20 ) ;5 sql语法:6string sqlStr=" SELECT * FROM orderInfo WHERE orderId > 20 ";(3) 关于“COUNT、SUM、MIN、MAX”函数的语句1 Linq语法:2var data=( from a in db.orderInfo select a ).Max( p=>p.orderId ) ;//查询该表中最⼤编号Id3var data=( from a in db.orderInfo select a ).Min( p=>p.orderId ) ;//查询该表中最⼩编号Id4var data=( from a in db.orderInfo select a ).Count() ;//查询该表数据总条数5var data=( from a in db.orderInfo select a ).Sum( p=>p.orderMoney ) ;//查询该表中所有消费额的总数(求和)6 Lamda语法:7var data=db.orderInfo.Max( t=>t.orderId );//查询该表中最⼤编号Id8var data=db.orderInfo.Min( t=>t.orderId );//查询该表中最⼩编号Id9var data=db.orderInfo.Count();//查询该表数据总条数10var data=db.orderInfo.Sum( t=>t.orderMoney );//查询该表中所有消费额的总数(求和)11 sql语法:12string sqlStr=" SELECT MAX(orderId) FROM orderInfo ";13string sqlStr=" SELECT MIN(orderId) FROM orderInfo ";14string sqlStr=" SELECT COUNT(*) FROM orderInfo ";15string sqlStr=" SELECT SUM(orderMoney ) FROM orderInfo ";(4) 关于数据排序的语句1 Linq语法:2var data=from a in db.orderInfo where a.orderId > 20orderby a.orderId descending select a ;//倒序排序,升序可⽤ascending关键字3 Lamda语法:4//情况⼀,根据单字段排序:5var data=db.orderInfo.OrderByDescending( t=>t.orderId ).Where( t=>t.orderId > 20 ) .ToList();//倒序排序,升序可⽤OrderBy关键字6//情况⼆,根据多字段主次排序:7var priceMonthEntities = priceMonthApp.GetList().OrderBy(t => t.F_Year).ThenBy(t => t.F_Month).ToList();//先按年升序,再按⽉升序8 sql语法:9string sqlStr=" SELECT * FROM orderInfo WHERE orderId > 20 ORDER BY orderId DESC ";//倒序排序,升序可⽤ASC关键字(5) 关于分页查询的语句1 Linq语法:2var data=( from a in db.orderInfo select a ) .Skip((pageIndex-1) * pageSize).Take(pageSize).ToList();3 Lamda语法:4var data=db.orderInfo.Skip((pageIndex-1)* pageSize).Take(pageSize).ToList();;//pageIndex:当前页码,pageSize:分页数据显⽰条数5 sql语法:6string sqlStr="SELECT TOP pageSize * FROM orderInfo WHERE orderId NOT IN(SELECT TOP( ( pageIndex - 1) * pageSize) orderId FROM orderInfo)";(6) 关于模糊查询(like)的语句1 Linq语法:2var data= from a in db.orderInfo where a.orderId.Contains(1) select a;//使⽤Contains关键字进⾏模糊匹配3 Lamda语法:4var data=db.orderInfo.Where(t=>t.F_UserId.Contains("1")).ToList();//使⽤Contains关键字进⾏模糊匹配5 sql语法:6string sqlStr="SELECT * FROM orderInfo WHERE orderId LIKE '%12%'";//使⽤like关键字进⾏模糊匹配(7) 关于分组查询的语句1 Linq语法:2var data= from a in db.orderInfo orderby a.orderId descending3 group a by a.orderType into s select new{4 s.key,//分组字段5 s.sMoney=s.Sum(a=>a.orderMoney),//分组后算出总的消费额6 s.maMoney=s.Max(a=>a.orderMoney),//分组后算出最⼤的消费额7 s.miMoney=s.Min(a=>a.orderMoney)//分组后算出最⼩的消费额8 };9 Lamda语法:10//使⽤GroupBy关键字进⾏分组查询(单个字段)11var data=db.orderInfo.GroupBy(p => p.recType).Select(t=>t.Key).ToList();12//使⽤GroupBy关键字进⾏分组查询(多个字段)13var data=db.orderInfo.GroupBy(p =>new{ p.recType,p.orderId}).Select(t=>new{ recType=t.Key.recType,orderId=t.Key.orderId}).ToList();14 sql语法:15string sqlStr="SELECT orderType , SUM(orderMoney), MAX(orderMoney), MIN(orderMoney) FROM orderInfo GROUP BY orderType";(8) 关于多表关联查询的语句1 Linq语法:2//使⽤join关键字进⾏表连接3var data= from a in db.orderInfo join e in db.orderType on a.orderTypeId equals e.id select r ;4var query=from t in db.orderInfo join s in db.orderType on t.orderTypeId equals s.id select5new {6 orderId=t.id,7 orderTypeName=,8 ...9 }10 Lamda语法:11var data=db.orderInfo.Join(db.orderType,t=>t.orderTypeId,s=>s.id,(t,s)=>t).OrderByDescending(t=>t.orderId).12 Select(13 t=> new{14 orderId=t.t.id,15 orderTypeName=,16 ...17 }).ToList(); //使⽤Join关键字进⾏表连接18 EF Core中的写法:19var data=db.orderInfo.Join(db.orderType,t=>t.orderTypeId,s=>s.id,(t,s)=>new{20 orderId=s.Id,21 .....22 }).toList();23 sql语法:(sql语句表关联有多种⽅法,在此只举⼀例)24string sqlStr="SELECT * FROM orderInfo o ,orderType t WHERE o.orderTypeId=t.id ORDER BY t.createDate";(9) 关于in查询的语句1 Linq语法:2var data= from a in db.orderInfo where (new int?[2213,43311,32422]).Contains(a.orderId) select a ;3 Lamda语法:4var data=db.orderInfo.Where(t=>(new int?[2213,43311,32422]).Contains(t.orderId)).ToList();5 sql语法:6string sqlStr="SELECT * FROM orderInfo WHERE orderId IN (2213,43311,32422)";(10) 关于去重查询的语句1 Linq语法:2var data= from a in db.orderInfo group p by new {a.orderTypeId} into _group select _group.FirstOrDefault(); //使⽤group关键字进⾏表数据去重3var data= from a in db.orderInfo group p by new {a.orderTypeId,...} into _group select _group.FirstOrDefault(); //使⽤group关键字对多个字段进⾏表数据去重 4 Lamda语法:5//单个去重:6var data=db.orderInfo.GroupBy(t=>t.orderTypeId).Select(r => r.First()).ToList(); //使⽤GroupBy关键字进⾏表数据去重7var data=db.orderInfo.DistinctBy(t=>t.orderTypeId).ToList(); //使⽤DistinctBy关键字进⾏表数据去重8//多个字段去重:9var data=db.orderInfo.GroupBy(t=>new{t.orderTypeId,...}).Select(r => r.First()).ToList(); //使⽤GroupBy关键字对多个字段进⾏表数据去重10var data=db.orderInfo.DistinctBy(t=>new{t.orderTypeId,...}).ToList(); //使⽤DistinctBy关键字对多个字段进⾏表数据去重11 sql语法:12string sqlStr="SELECT DISTINCT orderTypeId FROM orderInfo";//使⽤DISTINCT关键字进⾏表数据去重13string sqlStr="SELECT orderTypeId FROM orderInfo GROUP BY orderTypeId";//使⽤GROUP BY关键字进⾏表数据去重(11) 内连接 INNER JOIN1 Linq语法:2var ss = from r in db.Am_recProScheme3 join w in db.Am_Test_Result on r.rpId equals w.rsId4orderby r.rpId descending5select r;6 Lamda语法:7var ss1 = db.Am_recProScheme.Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).OrderByDescending(p => p.rpId).ToList();8 sql语法:9string sssql = "SELECT r.* FROM Am_recProScheme AS r INNER JOIN Am_Test_Result AS t ON r.[rpId] = t.[rsId] ORDER BY r.[rpId] DESC"; (12) 左连接 LEFT JOIN1//两个DataTable关联,查找只在第⼀个表中的数据2static void Main(string[] args)3 {4 DataTable dt1 = new DataTable("Ta");5 DataTable dt2 = new DataTable("Tb");6 dt1.Columns.Add("ID", typeof(int));7 dt1.Columns.Add("Name", typeof(string));8 dt1.Rows.Add(1, "⼩明");9 dt1.Rows.Add(2, "⼩红");10 dt1.Rows.Add(3, "⼩⿊");11 dt2.Columns.Add("ID", typeof(int));12 dt2.Columns.Add("Name", typeof(string));13 dt2.Rows.Add(1, "⼩黄");14 dt2.Rows.Add(2, "⼩红");15 dt2.Rows.Add(3, "⼩强");16⽅法⼀:Linq语法17var query = from q1 in dt1.AsEnumerable()18 join q2 in dt2.AsEnumerable()19 on q1.Field<string>("Name") equals q2.Field<string>("Name") into tmp20from q3 in tmp.DefaultIfEmpty()21where q3 == null22select new23 {24 ID = q1.Field<int>("ID"),25 Name = q1.Field<string>("Name")26 };27⽅法⼆:Lamda语法28var query = dt1.AsEnumerable().GroupJoin(29 dt2.AsEnumerable(),30 x => x.Field<string>("Name"),31 y => y.Field<string>("Name"),32 (x, y) => y.DefaultIfEmpty(). Where(w => w == null).33 Select(z => new { ID = x.Field<int>("ID"), Name = x.Field<string>("Name") })34 ).SelectMany(x => x);35foreach (var item in query)36 {37 Console.WriteLine($"ID={item.ID} Name={}");38 }39 Console.Read();40 }(13) 三表连接1 SELECT id, name, jname, cname2 FROM userinfo u3 LEFT JOIN job j on u.job = j.jid4 LEFT JOIN city c on u.city = c.cid56var list = (7from u in erinfos8 join j in dc.jobs on u.job equals j.jid into j_join9from x in j_join.DefaultIfEmpty()10 join c in dc.cities on u.city equals c.cid into c_join11from v in c_join.DefaultIfEmpty()12select new13 {14 id = u.id,15 name = ,16 jname = x.jname,17 cname = ame,18/*u1=u,x1=x,v1=v*/19//不要⽤对象的⽅式因为对象可能为null那么对象.属性就会抛异常20 }21 ).ToList();2223for (var i = 0; i < list.Count(); i++)24 {25 Console.WriteLine(list[i].name + '\t' + list[i].jname + '\t' + list[i].cname); //字段为null不报异常26//Console.WriteLine(list[i]+'\t'+list[i].x1.jname+'\t'+list[i]ame+"\r\n"); //对象x1 v1 有可能为null 抛异常27 }28 Console.ReadLine();(14) 实例⽤法:1//数据库 + ⾃定义名称 =new 数据库2 mydbDataContext con = new mydbDataContext();3//模糊查询表达式中⽤.Contains4 con.car.Where(r=>.Contains(TextBox1.Text.Trim())).ToList();5//开头查⽤.StartWith6 con.car.Where(r => .StartsWith(TextBox1.Text)).ToList();7//结尾查⽤.EndWith8 con.car.Where(r => .EndsWith(TextBox1.Text)).ToList();9//最⼤值10 con.car.Max(r => r.price * r.oil).ToString();11//最⼩值12 con.car.Min(r => r.price).ToString();13//求和14 con.car.Sum(r => r.price).ToString();15//平均值16 con.car.Average(r => r.price).ToString();17//升序:18 con.car.OrderBy(r => r.price).ToList();19//降序:20 con.car.OrderByDescending(r => r.price).ToList();2122//上⼀页,下⼀页,组合查询:23int PageCount = 5;//每页显⽰条数24//上⼀页,PageCount_Label.Text为当前页码25int pageNum = Convert.ToInt32(PageCount_Label.Text) - 1;26 Repeater1.DataSource = con.car.Skip((pageNum - 1) * PageCount).Take(PageCount);27 Repeater1.DataBind();28 PageCount_Label.Text = pageNum.ToString();29//下⼀页30int pageNum = Convert.ToInt32(PageCount_Label.Text) + 1;31 Repeater1.DataSource = con.car.Skip((pageNum - 1) * PageCount).Take(PageCount);32 Repeater1.DataBind();33 PageCount_Label.Text = pageNum.ToString();34//组合查询的点击事件35 List<car> list = con.car.ToList();36if (TextBox2.Text != "")37 {38 List<car> list1 = con.car.Where(r => .Contains(TextBox2.Text)).ToList();39 list = list.Intersect(list1).ToList();40 }41if (TextBox3.Text != "")42 {43 List<car> list1 = con.car.Where(r => r.oil == Convert.ToDecimal(TextBox3.Text)).ToList();44 list = list.Intersect(list1).ToList();45 }46if (TextBox4.Text != "")47 {48 List<car> list1 = con.car.Where(r => r.powers == Convert.ToInt32(TextBox4.Text)).ToList();49 list = list.Intersect(list1).ToList();50 }51 Repeater1.DataSource = list;52 Repeater1.DataBind();。
Linq基础+Lambda表达式对数据库的增删改及简单查询
Linq基础+Lambda表达式对数据库的增删改及简单查询⼀、Linq to sql 类⾼集成化的数据库访问技术使⽤Linq可以代替之前的,省去了⾃⼰敲代码的实体类和数据访问类的⼤量⼯作实体类:添加⼀个Linq to sql 类 ----选择要使⽤的数据库---- 拖⼊要使⽤的表需要⽴即保存就相当于创建实体类如果进⾏属性扩展,在App_Code下添加类,类名同表名⼀致。
将该类在访问修饰符后加上partial,将该类定为实体类的⼀部分数据访问类:不⽤在App_Code下再建数据访问类了。
直接在使⽤数据访问类的地⽅⽤数据库上下⽂进⾏编写。
ers.ToList(); //是将Users表转化为⼀个泛型集合。
也就相当于查询全部的⽅法⼆、利⽤Linq对数据库进⾏相关操作1、添加数据每⼀条数据都是⼀个实体类对象。
先将其实例化出来,再给对象的每个属性赋值。
在数据访问类中进⾏添加数据操作添加的⽅法:ers.InsertOnSumbit(对象);⽅法执⾏结束后提交对数据库的更改:con.SubmitChanges();2、删除数据删除数据前要先查到这条数据再进⾏删除操作通过ids进⾏查询这条数据返回⼀个对象Users u = ers.Where(r=>r.ids.Tostring()==ids).FirstOrDefault();where括号内接的是Lambda表达式,r代表⼀个Users对象,=>是基本格式,FirstOrDefault()返回第⼀条数据或者返还空如果u不是空,则在数据访问类中进⾏删除。
ers.DeleteOnSubmit(对象);con.SubmitChanges();3、数据修改数据的修改同样也是需要先查到这条数据,将返回的这个对象的要修改的属性进⾏重新赋值最后con.SubmitChanges();4、简单数据查询直接在数据访问类中根据对象的属性进⾏查询,多个查询条件中间⽤ && 连接;如 ers.Where(r=>erName=="zhangsan" && r.PassWord=="123").FirstOrDefault();。
linq常用语法和方法
linq常用语法和方法LINQ(Language Integrated Query)是一种强大的查询语言,用于在.NET框架中查询各种数据源。
它提供了许多常用的语法和方法,用于对数据进行筛选、排序、聚合等操作。
以下是一些LINQ常用的语法和方法:1. 查询语法(Query Syntax):通过使用标准的LINQ查询运算符(如`from`、`where`、`select`、`orderby`等),可以编写结构化查询语句。
例如:```csharpvar query = from item in collectionwhere == valueselect item;```2. 扩展方法语法(Extension Methods Syntax):通过使用LINQ扩展方法,可以使用Lambda表达式和委托来编写查询。
这些扩展方法提供了简洁的语法,以便对各种数据源进行操作。
例如:```csharpvar query = (item => == value);```3. 聚合操作:LINQ提供了许多聚合操作符,如`Count()`、`Sum()`、`Average()`等,可以对查询结果进行统计和计算。
例如:```csharpvar count = ();var sum = (item => );```4. 排序操作:使用`OrderBy()`和`OrderByDescending()`方法可以对查询结果进行排序。
还可以使用`ThenBy()`方法进行多级排序。
例如:```csharpvar sorted = (item => );```5. 转换操作:使用`Select()`方法可以对查询结果进行转换,将每个元素转换为指定的类型或表达式。
例如:```csharpvar transformed = (item => + " converted");```6. 分组操作:使用`GroupBy()`方法可以对查询结果进行分组,并根据指定的键对每个组进行聚合。
jQuery扩展半Lambda表达式类似Linq的Where
jQuery扩展半Lambda表达式类似Linq的Where⾸先要载⼊jquery//半Lambda表达式的Javascript,返回ListArray.prototype.where = function (s) { return eval("(jQuery.grep(this, function (o, i){return " + s + ";}))"); }除去空格仅有98个字符(这扩展够精简的了,也可以拆出来⽤jQuery.grep但如果页⾯上很多地⽅⽤到,代码就多了)有⼈说依赖jQuery不好⽤(现在多少系统写JS必备jquery,这个不说)有⼈说eval效率差(请你⾃⼰试试,能不能在项⽬中使⽤,反正这个where我在项⽬中⽤很多,并不见得卡)使⽤⽅法:Demo 1://基础var arr = [3,5,7,8];var list1 = arr.where("o > 5") ; //得到[7,8]var list2 = arr.where("i < 3"); // 得到[3,5,7]Demo 2: //进阶var arr = [{id:1,name:"Jay"},{id:2,name:"Joy"},{id:3,name:"Bob"}];var list1 = arr.where(" == 'Joy'"); //得到 [{id:2,name:"Joy"}] ;var list2 = arr.where(".indexOf('o')!=-1");//得到name含有'o'字母的 [{id:2,name:"Joy"},{id:3,name:"Bob"}];Demo 3: //⾼级var arr =[{name:"Jay",age:29,c:[{name:"A"},{name:"B"}]},{name:"Jay",age:26,c:[]},{name:"Jay",age:24,c:[{name:"C"}]}];var list1 = arr.where("o.age > 25 && !o.c && o.c.length > 0");//年龄⼤于25且⾄少有⼀个孩⼦ [{name:"Jay",age:29,children:[{name:"A"},{name:"B"}]}]提醒:得到的list是原来的对象,不是副本,通过 list1[0].name = "XX" 可以更改 arr[0]的name缺点: where被扩展到Array中,for(var i in arr) 会遍历到 where 因此,以后想⽤for要做好判断或者采⽤ $(arr).each(function(i,o){ })取代(建议) ,也可以不扩展到Array,⾃⼰写全局Function 有些什么不⾜或建议,希望⼤家提出来改进,谢谢!。
.NET4.0 Lambda表达式
4.0 Lambda表达式Lambda表达式是一种高效的类似于函数式编程的表达式,Lambda简化了开发中需要编写的代码量。
Lambda表达式是由.NET 2.0演化过来的,也是LINQ的基础。
熟练地掌握Lambda表达式能够快速上手LINQ应用开发。
1.匿名方法在了解Lambda 表达式之前,需要了解什么是匿名方法。
匿名方法简单地说,就是没有名字的方法。
而通常情况下的方法定义是需要名字的,示例代码如下所示。
上面这个方法就是一个常规方法,这个方法需要方法修饰符(public)、返回类型(int)方法名称(sum)和参数列表。
而匿名方法可以看作是一个委托的扩展,是一个没有命名的方法。
示例代码如下所示。
上述代码声明了一个匿名方法Sum 但是没有实现匿名方法的操作的实现。
在声明匿名方法对象时,可以通过参数格式创建一个匿名方法。
匿名方法能够通过传递的参数进行一系列操作,示例代码如下所示。
上述代码使用了s(10,12)方法进行两个数的加减。
匿名方法虽然没有名称,但是同样可以使用"("")"号进行方法的使用。
结合上述代码,该实例的全部代码如下所示。
执行上述代码,结果如图9-11所示。
图9-11 执行结果除此之外,匿名方法还能够使用一个现有的方法作为其方法的委托。
示例代码上述代码声明了一个匿名方法,并声明了一个普通的方法。
在代码中使用匿名将方法名作为参数进行传递。
上述代码中变量s就是一个匿名方法,这个匿名方法的方法体被声明为retSum。
编译器进行编译时,匿名方法会使用retSum执行其方法体并进行运算。
匿名方法最明显的好处就是可以降低常规方法编写时的工作量,另外一个好处就是可以访问调用者的变量,降低传参数的复杂度。
2.Lambda表达式基础在了解了匿名方法后,就能够开始了解Lambda表达式。
Lambda表达式在一定程度上就是匿名方法的另一种表现形式。
为了方便对Lambda表达式的解释,首先需要创建一个People类,示例代码如下所示。
第21章.使用LINQ查询
特别惠团购网(高品质、超低价) 第21章使用LINQ查询了解了基本的LINQ基本概念,以及Lambda表达式基础后,就能够使用LINQ进行应用程序开发。
LINQ使用了Lambda表达式,以及底层接口实现了对集合的访问和查询,开发人员能够使用LINQ对不同的对象,包括数据库、数据集和XML文档进行查询。
21.1 LINQ查询概述LINQ可以对多种数据源和对象进行查询,如数据库、数据集、XML文档甚至是数组,这在传统的查询语句中是很难实现的。
如果有一个集合类型的值需要进行查询,则必须使用Where等方法进行遍历,而使用LINQ可以仿真SQL语句的形式进行查询,极大的降低了难度。
21.1.1 准备数据源既然LINQ可以查询多种数据源和对象,这些对象可能是数组,可能是数据集,也可能是数据库,那么在使用LINQ进行数据查询时首先需要准备数据源。
1.数组特别惠团购网(高品质、超低价) 数组中的数据可以被LINQ查询语句查询,这样就省去了复杂的数组遍历。
数组数据源示例代码如下所示。
string[] str = { "学习", "学习LINQ", "好好学习", "生活很美好" };int[] inter = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };数组可以看成是一个集合,虽然数组没有集合的一些特性,但是从另一个角度上来说可以看成是一个集合。
在传统的开发过程中,如果要筛选其中包含“学习”字段的某个字符串,则需要遍历整个数组。
2.SQL Server在数据库操作中,同样可以使用LINQ进行数据库查询。
LINQ以其优雅的语法和面向对象的思想能够方便的进行数据库操作,为了使用LINQ进行SQL Server数据库查询,可以创建两个表,这两个表的结构如下所示。
Student(学生表):S_ID:学生ID。
S_NAME:学生姓名。
linq左连接的lambda语句
LINQ左连接的Lambda语句详解在 LINQ(Language Integrated Query)中,左连接是一种非常有用的查询操作,它允许我们从两个或多个数据源中获取数据,并根据指定的条件将它们组合在一起。
在左连接中,我们可以在右侧数据源中没有匹配左侧数据源的项时仍然获取左侧数据源中的数据。
在C#中,我们可以使用Lambda表达式来执行LINQ左连接查询。
下面是一个示例,演示如何使用Lambda表达式执行 LINQ 左连接查询:在上面的示例中,我们有两个数据源leftData和rightData,分别表示左侧和右侧的数据。
我们使用join关键字执行左连接操作,将leftData和rightData 根据Id和LeftId字段进行匹配。
into rightGroup关键字用于创建一个临时的分组变量rightGroup,该变量将包含所有与左侧数据匹配的右侧数据项。
DefaultIfEmpty()方法用于处理右侧数据中没有匹配项的情况,它将返回一个默认的空值(null)。
最后,我们使用select关键字创建一个匿名类型的对象,其中包含左侧数据的Id、Name和右侧数据的Value字段。
Lambda表达式版本的查询如下所示:在这个Lambda表达式版本的查询中,我们使用Join方法执行左连接操作。
第一个参数是左侧数据源,第二个参数是左侧数据的比较键(即用于匹配的字段),第三个参数是右侧数据的比较键(即用于匹配的字段),第四个参数是结果选择器函数,用于创建包含所需字段的匿名类型对象。
在这个选择器函数中,我们使用空合并运算符(null coalescing operator)处理右侧数据为空的情况,以确保结果中不会包含无效的null值。
linq左连接的lambda语句
linq左连接的lambda语句(实用版)目录1.LINQ 简介mbda 表达式简介3.LINQ 左连接的概念4.使用 Lambda 表达式实现 LINQ 左连接5.示例代码及解析正文1.LINQ 简介LINQ(Language Integrated Query,即语言集成查询)是.NET Framework引入的一种强大的查询技术,它将查询功能与编程语言(如C#和)相结合,允许程序员使用熟悉的编程语言语法编写查询语句,从而简化了数据查询操作。
mbda 表达式简介Lambda 表达式是一种简洁的匿名函数表示形式,它可以在 LINQ 查询中使用,用于定义查询条件、排序规则等。
Lambda 表达式的基本形式为:“参数 1 参数 2...=> 表达式/操作”,例如:x => x + 1 表示一个以 x 为参数的匿名函数,返回值为 x+1。
3.LINQ 左连接的概念在数据库查询中,左连接(Left Join)是一种将两个表中的记录按照某个条件进行连接的操作,结果集包含左表和右表中所有符合条件的记录,如果右表中没有符合条件的记录,则结果集中的右侧字段将为空。
4.使用 Lambda 表达式实现 LINQ 左连接在 LINQ 查询中,我们可以使用 LeftJoin 方法实现左连接操作,Lambda 表达式用于定义连接条件。
以下是一个使用 Lambda 表达式实现LINQ 左连接的示例:```csharpusing System;using System.Collections.Generic;using System.Linq;public class Employee{public int EmployeeID { get; set; }public string Name { get; set; }public int DepartmentID { get; set; }}public class Department{public int DepartmentID { get; set; }public string Name { get; set; }}class Program{static void Main(string[] args){List<Employee> employees = new List<Employee>{new Employee { EmployeeID = 1, Name = "张三", DepartmentID = 1 },new Employee { EmployeeID = 2, Name = "李四", DepartmentID = 2 },new Employee { EmployeeID = 3, Name = "王五", DepartmentID = 1 }};List<Department> departments = new List<Department> {new Department { DepartmentID = 1, Name = "人事部" },new Department { DepartmentID = 2, Name = "财务部" }};var query = from e in employeesjoin d in departments on e.DepartmentID equals d.DepartmentID into joinedfrom d in joinedwhere d.DepartmentID == 2select new { e.EmployeeID, , };foreach (var item in query){Console.WriteLine("EmployeeID: {0}, Name: {1}, Department: {2}", item.EmployeeID, , );}}}```在这个示例中,我们首先使用 from 子句定义了一个 LINQ 查询,接着使用 join 子句实现了左连接操作。
c#Linq查询
c#Linq查询c#提供的ling查询极⼤的遍历了集合的查询过程,且使⽤简单⽅便,⾮常的有⽤。
下⾯将分别⽤简单的例⼦说明:ling基本查询、延迟查询属性、类型筛选、复合from字句、多级排序、分组查询、联合查询、合并、分页、聚合操作符、并⾏linq、取消长时间运⾏的并⾏ling查询。
Lambda表达式简介:/*Lambda表达式:Lambda 表达式是⼀种可⽤于创建委托或表达式⽬录树类型的匿名函数表达式位于 => 运算符右侧的 lambda 表达式称为“表达式 lambda”。
* (input parameters) => expression* ⽰例:*/delegate int del(int i);static void Main(string[] args){del myDelegate = x => x * x;int j = myDelegate(5); //最后j = 25}基本查询语句:var query = from r in listStudents where r.score < 60orderby r.score descending select r;//var q2 = listStudents.Where(r => r.score < 60).OrderByDescending(r => r.score).Select(r => r) ;//或使⽤Lambda表达式例⼦:///<summary>///学⽣结构体///</summary>struct Student{///<summary>///姓名///</summary>public string name;///<summary>///年龄///</summary>public int age;///<summary>///班号///</summary>public int grade;///<summary>///分数///</summary>public float score;}///<summary>/// linq///基本查询///</summary>static void Linq1(){#region构造查询数据List<Student> listStudents = new List<Student>();Random pRandom = new Random();for (int i = 1; i < 50; i++){float sc = pRandom.Next(0, 100);int age = pRandom.Next(8, 13);int gde = pRandom.Next(1, 6);string name = "";switch (pRandom.Next(0, 6)){case1: name = "周xxx"; break;case2: name = "李xxx"; break;case3: name = "孙xxx"; break;case4: name = "钱xxx"; break;default: name = "赵xxx"; break;}Student psdt = new Student(); = name;psdt.age = age;psdt.grade = gde;psdt.score = sc;listStudents.Add(psdt);}#endregion//从50个学⽣中选择出不及格的⼈员名单并按分数降序排列var query = from r in listStudents where r.score < 60orderby r.score descending select r;//var q2 = listStudents.Where(r => r.score < 60).OrderByDescending(r => r.score).Select(r => r) ;//或使⽤Lambda表达式 //orderby升序即从⼩到⼤,orderby r.score descending降序即从⼤到⼩Console.WriteLine("不及格的⼈员名单:");foreach (Student st in query){Console.WriteLine("***************");Console.WriteLine("姓名:"+);Console.WriteLine("班级:"+st.grade);Console.WriteLine("年龄:"+st.age);Console.WriteLine("分数:"+st.score);}Console.ReadKey();}View Code延迟查询属性linq查询为延迟查询,只需构造⼀次查询语句,可以多次使⽤。
(完整word版)Lambda表达式详细总结
(一)输入参数在Lambda表达式中,输入参数是Lambda运算符的左边部分。
它包含参数的数量可以为0、1或者多个。
只有当输入参数为1时,Lambda表达式左边的一对小括弧才可以省略。
输入参数的数量大于或者等于2时,Lambda表达式左边的一对小括弧中的多个参数质检使用逗号(,)分割。
示例1下面创建一个Lambda表达式,它的输入参数的数量为0.该表达式将显示“This is a Lambda expression”字符串。
[csharp]view plain copy1.()=>Console.WriteLine("This is a Lambda expression.");分析2由于上述Lambda表达式的输入参数的数量为0,因此,该Lambda表达式的左边部分的一对小括弧不能被省略。
示例2下面创建一个Lambda表达式,它的输入参数包含一个参数:m。
该表达式将计算m参数与2的乘积。
[csharp]view plain copy1.m=>m*2;分析2上述Lambda表达式的输入参数省略了一对小括弧,它与“(m)=>m*2”Lambda表达式是等效的。
示例3下面创建一个Lambda表达式,它的输入参数包含两个参数:m和n。
该表达式将计算m和n参数的乘积。
[csharp]view plain copy1.(m,n)=>m*n;(二)表达式或语句块多个Lambda表达式可以构成Lambda语句块。
语句块可以放到运算符的右边,作为Lambda的主体。
根据主题不同,Lambda表达式可以分为表达式Lambda和语句Lambda。
语句块中可以包含多条语句,并且可以包含循环、方法调用和if语句等。
示例1下面创建一个Lambda表达式,它的右边部分是一个表达式。
该表达式计算m参数的平方值。
[csharp]view plain copy1.m=>m*n;分析1如果Lambda表达式的右边部分是一个语句块,那么该语句块必须被"{"和"}"包围。
linq基本语法
linq基本语法LINQ(LanguageIntegratedQuery)是一种集成查询语言,可用于查询各种数据源,包括集合、数据库、XML 文件等。
本文将介绍 LINQ 的基本语法,包括 LINQ 查询表达式、Lambda 表达式和 LINQ 方法语法。
1. LINQ 查询表达式LINQ 查询表达式是一种类似于 SQL 语句的语法,用于从数据源中查询数据。
语法格式如下:```var result = from x in datawhere conditionselect x;```其中,data 是数据源,x 是数据源中的元素,condition 是查询条件,select x 是选取符合条件的元素。
例如,查询集合中所有大于 5 的元素可以写成:```var numbers = new int[] { 1, 3, 5, 7, 9 };var result = from n in numberswhere n > 5select n;```2. Lambda 表达式Lambda 表达式是一种匿名函数,可以用于 LINQ 查询中。
Lambda 表达式的语法格式如下:```var result = data.Where(x => condition).Select(x => x); ```其中,Where 方法用于筛选符合条件的元素,Select 方法用于选取元素。
例如,查询集合中所有大于 5 的元素可以写成:```var numbers = new int[] { 1, 3, 5, 7, 9 };var result = numbers.Where(n => n > 5).Select(n => n); ```3. LINQ 方法语法LINQ 方法语法是一种链式调用的语法,用于从数据源中查询数据。
语法格式如下:```var result = data.Where(x => condition).Select(x => x); ```其中,Where 方法用于筛选符合条件的元素,Select 方法用于选取元素。
c委托的使用场景
c委托的使用场景c委托是C#语言中的一种重要的编程方式,旨在简化代码结构,提高代码的可读性和可维护性。
c委托可以理解为一种“函数指针”,可以将一个函数作为参数传递给另一个函数,也可以将一个函数作为返回值返回给调用者。
c委托的使用场景非常广泛,以下是几个常见的应用场景:1. 事件处理在C#中,事件处理是一种常见的设计模式。
通过使用c委托,可以将事件处理程序注册到相应的事件上,并在事件发生时自动调用相应的函数。
比如,Windows窗体程序中的按钮单击事件,可以通过c委托来实现。
2. 回调函数回调函数是一种常见的编程方式,它允许在一个函数执行完成后,自动调用另一个函数。
在C#中,也可以通过c委托来实现回调函数。
比如,当一个线程完成时,可以通过c委托来通知主线程。
3. 委托链c委托支持链式调用,也就是将多个函数串起来依次调用。
这种编程方式被称为委托链。
委托链可以应用于很多场景,比如,在一个复杂的算法中,可以将多个函数分别实现不同的功能,然后通过委托链将它们串联起来。
4. Lambda表达式lambda表达式是C# 3.0引入的一个新特性,它允许将一个匿名函数作为委托使用。
lambda表达式可以简化代码结构,并且使代码更易于阅读和理解。
比如,在LINQ查询中,lambda表达式可以用来表示查询条件和变换操作。
总之,c委托是C#语言中非常重要的一种编程方式,它可以应用于很多场景,包括事件处理、回调函数、委托链和Lambda表达式等。
在实际开发中,合理地应用c委托可以提高代码的可读性和可维护性,从而节省开发时间和维护成本。
.NetLinq与Lambda表达式中GroupBy以多个字段分组
.NetLinq与Lambda表达式中GroupBy以多个字段分组
⼀、引⼊
基本上熟悉C#语⾔的没有不知道Lambda表达式的,其对于数据的处理真的是太⽅便了。
其中分组处理的GroupBy⽅法在List中的使⽤⾮常⼴泛。
正式近期⼀个功能需求中⼜遇到了,⽽且是需要GroupBy多个字段的。
现在功能已经完成,处理得到了想要数据,就顺便来记录⼀下,⽅便下次的查阅。
⼆、代码
这⾥我就直接贴出来我的项⽬代码截图了,基本只要看到了就知道该怎么⽤了,代码写的不规范的地⽅还请海涵。
注:1、list是从数据库中获取到的List集合,需要就这个集合中的两个字段(account,room_id)进⾏分组
2、ViewPlayerRecord是⼀个实体类,⽤于传递显⽰在前端的相关字段
3、该Lambda表达式实现了以两个字段分组再获取⾃⼰想要的数据的功能,虽然简单,但是长时间不⽤还真容易忘记细节。
4、GroupBy(x => new { x.a , x.b, x.c }).Select( x=> ( new Class名 { a=x.Key.a , b=x.Key.b , c = x.Key.c } ))。
EFcore中用lambda表达式和Linq的一些区别
EFcore中⽤lambda表达式和Linq的⼀些区别转眼⼀看,⼜过了10⼏天没有写博客了,主要还是没有什么可以写的,因为遇到的问题都不是很有价值。
不过最近发现⽤lambda表达式,⽐⽤Linq的代码量会少⼀些,⽽且也⽅便⼀些。
不过两者都差不多,相差不是特别⼤。
在EF core中,表和表之中都有对应的关系,例如⼀对⼀,⼀对多,还有多对多。
要实现⼀对⼀,⼀对多加上主外键,实现多对多则需要加上⼀个中间表,这样结构清晰,维护也⾮常的⽅便。
那我们在使⽤EF core 势必要⽤到⾮常多的跨表查询,来看看linq是怎样查找数据库中的信息的:var query = from a in db.ExaminationOrderInfojoin b in db.ExaminationOrganization on anizationId equals anizationIdjoin c in db.Customerinfo on a.CustomerId equals c.CustomerIdjoin d in db.Supplierinfo on anizationId equals anizationIdwhere (a.IsDelete == 0)&& (appointmentResult == null || a.AppointmentResult == appointmentResult)&& (isPaperReport == null || a.IsPaperReport == isPaperReport)&& (examinationStatus == null || a.ExaminationStatus == examinationStatus)&& (name == null || == name)&& (id == null || a.IdCard == id)&& (organizationName == null || == organizationName)&& (customer == null || == customer)&& (supplierName == null || == supplierName)orderby a.AppayTimeselect new ExaminationOrderInfoDto{Type = a.Type == 1 ? "取消预约" : "预约",IdCard = a.IdCard,Name = ,StartTime = a.StartTime.ToString(),EndTime = a.EndTime.ToString(),AppayTime = a.AppayTime,ExaminationTime = a.ExaminationTime.ToString(),AppointmentResult = a.AppointmentResult == 2 ? "成功" : a.AppointmentResult == 1 ? "失败" : "待处理",ExaminationStatus = a.ExaminationStatus == 1 ? "已登记" : "未登记",IsPaperReport = a.IsPaperReport == 1 ? "已打印" : "未打印",ElectronicReport = a.ElectronicReport,Organization = ,Customer = ,SupplierName = };可以看出连接了三张表去查询也就是 join....on.... ,然后加上排序,这样代码会偏多⼀点。
C#Linq之Lambda表达式GroupBy()的两种用法
C#Linq之Lambda表达式GroupBy()的两种⽤法前⾔GroupBy通常⽤于分组统计,可根据单字段或某些字段区进⾏合并统计数据Lambda的思想与SQL语句类型,如以下例⼦:统计和B、C、D同组的数量⽤法1List<Order> Orders= samples.GroupBy(p => new { p.B, p.C, p.D}) //D,B,C是samples的属性.Select(p => new Order{B= p.Key.B,C= p.Key.C,D= p.Key.D,Qty = p.Sum(a => a.Qty),A= p.Select(a => a.A).FirstOrDefault().ToString()}).ToList();说明:根据单个字段合并的时候details.GroupBy(p=>p.B),多个字段合并的时候是details.GroupBy(p=>new{p.B,d.C}) Select(p => new samples{D=p.Key.D,A=p.Select(a=>a.A).FirstOrDefault().ToString(),Qty=p.sum(a=>a.Qty)})说明:(1).如果在GroupBy()中存在的字段就直接p.Key.字段(2).合并求和 Qty=p.sum(a=>a.Qty) 此处的a代指的是samples中特征相同但未合并的项,p指的是合并后的项(3)GroupBy中没有的项可通过A= p.Select(a => a.A).FirstOrDefault().ToString()⽤法2上述代码可写成下⾯的模式:List<Order> Orders= samples.GroupBy(p => new { p.B, p.C, p.D}, p => p.Qty, (key, g) => new Order{H= Key.B,D= Key.C,C= Key.D,Qty = g.Sum(),A= p.Select(a => a.A).FirstOrDefault().ToString()}).ToList();说明:(key,g)中的 key是GroupBy()的第⼀个参数,g就是GroupBy()的第⼆个参数。
Lambda表达式多表连接的左连
Lambda表达式多表连接的左连 在⽹上有很多⼈都在查找Lambda的例⼦,但是完整的例⼦不多,况且还有相当⼀部分⼏乎完全不能⽤,LINQ的左连倒是挺多的,但是LINQ的代码相对⽐较少,⼀旦遇到重复数据的时候,不容易被过滤,Lambda就可以轻松避免这个让⼈头疼的问题。
废话不多说,看下⾯的例⼦吧。
var model_main = from o in db.Main where o.OrderIsdel == 0 select o;var model_user = from u in er select u;var model_device = from d in db.Device select d;var model_team = from t in db.Team select t;var sub_model = from sub in db.SubOrder select sub;var model_order_user = model_main.GroupJoin(model_user, o => o.OrderUserId, u => erId, (o, u) => new { o, u }).SelectMany(p => p.u.DefaultIfEmpty(), (p, u) => new OrderModel(){OrderDeviceId = p.o.OrderDeviceId,OrderId = p.o.OrderId,OrderUserId = p.o.OrderUserId,OrderTeamID = p.o.OrderTeamID,OrderUserNickName = erName,});var model_order_user_device = model_order_user.GroupJoin(model_device, o => o.OrderDeviceId, d => d.DeviceId, (o, d) => new { o, d }).SelectMany(p => p.d.DefaultIfEmpty(), (p, d) => new OrderModel(){OrderDeviceId = p.o.OrderDeviceId,OrderId = p.o.OrderId,OrderUserId = p.o.OrderUserId,OrderTeamID = p.o.OrderTeamID,OrderUserNickName = p.o.OrderUserNickName,DeviceName = d.DeviceName,DeviceAddress = d.DeviceAddress,DeviceZone = d.DeviceZone});var model_order_user_device_team = model_order_user_device.GroupJoin(model_team, o => o.OrderTeamID, t => t.TeamId, (o, t) => new { o, t }).SelectMany(p => p.t.DefaultIfEmpty(), (p, t) => new OrderModel() {OrderDeviceId = p.o.OrderDeviceId,OrderId = p.o.OrderId,OrderUserId = p.o.OrderUserId,OrderTeamID = p.o.OrderTeamID,OrderUserNickName = p.o.OrderUserNickName,DeviceName = p.o.DeviceName,DeviceAddress = p.o.DeviceAddress,DeviceZone = p.o.DeviceZone,TeamSerisNumber = t.TeamSerisNumber,});var model = model_order_user_device_team.GroupJoin(sub_model, o => o.OrderId, s => s.SubOrderParentId, (o, s) => new { o, s }).SelectMany(p => p.s.DefaultIfEmpty(), (p, s) => new OrderModel(){OrderDeviceId = p.o.OrderDeviceId,OrderId = p.o.OrderId,OrderUserId = p.o.OrderUserId,OrderTeamID = p.o.OrderTeamID,OrderUserNickName = p.o.OrderUserNickName,DeviceName = p.o.DeviceName,DeviceAddress = p.o.DeviceAddress,DeviceZone = p.o.DeviceZone,GoodsCount = sub_model.Where(sub => sub.SubOrderParentId == p.o.OrderId).Sum(sub => sub.SubOrderGoodsNumber),});GroupJoin前⾯部分是左连的集合,⾥⾯的参数分别是右边的集合、左边集合的外键、右边集合的主键、两个集合的对象、查找的集合。
linq拉姆达表达式 like 开头字符
linq拉姆达表达式like 开头字符在LINQ中,可以使用Lambda表达式和`StartsWith`方法来模拟SQL中的`LIKE`以查找以指定字符串开头的项。
以下是一个简单的示例:假设有一个名为`people`的集合,其中包含`Person`对象,每个`Person`对象都有一个`Name`属性。
我们想要查找名字以特定前缀开头的人。
这可以通过使用`Where`方法和Lambda表达式来实现。
```csharpusing System;using System.Collections.Generic;using System.Linq;class Program{static void Main(){// 创建一个包含Person对象的集合List<Person> people = new List<Person>{new Person { Name = "John" },new Person { Name = "Jane" },new Person { Name = "Bob" },new Person { Name = "Alice" }};// 搜索名字以特定前缀开头的人string prefix = "J";var results = people.Where(p => .StartsWith(prefix));// 输出结果Console.WriteLine($"People with names starting with '{prefix}':");foreach (var person in results){Console.WriteLine();}}}// 定义Person类class Person{public string Name { get; set; }}```在上述示例中,`people.Where(p => .StartsWith(prefix))`这一行使用了Lambda表达式和`StartsWith`方法,以查找名字以特定前缀开头的人。
.net 匿名方法
.net 匿名方法.NET 匿名方法,也叫做 lambda 表达式,是一种匿名函数,可以在 C# 和其他 .NET 语言中使用。
它提供了一种简单而强大的方式来定义方法,同时避免了定义命名方法的一些繁琐。
在 C# 中,匿名方法可以用于事件处理程序、线程和并行编程、LINQ 查询等。
而在其他 .NET 语言中,也可以使用匿名方法来实现相应的功能。
下面我们就来详细了解一下 .NET 匿名方法的相关知识点。
匿名方法的定义通常包括一个委托类型、关键字 delegate,以及方法的参数和方法体。
以下是一个简单的匿名方法示例:```csharpdelegate int MyDelegate(int x, int y);在这个示例中,我们创建了一个委托类型 MyDelegate,该类型可以表示一个具有两个 int 类型参数和返回值的方法。
然后,我们使用关键字 delegate 来定义一个匿名方法并将其分配给 add 变量。
这个匿名方法实现了一个简单的加法运算。
在 C# 中,匿名方法的语法可以使用 lambda 表达式进行简化。
例如,我们可以将上面的示例重新写为:这里,我们使用一个箭头(=>)来代替关键字 delegate,也省略了方法体的大括号和return 语句。
使用匿名方法的最大优点就是它可以避免定义命名方法,从而减少代码量和提高代码的可读性。
此外,匿名方法还可以提升代码的灵活性和可维护性。
例如,当我们需要在事件处理程序中创建一个简单的回调函数时,使用匿名方法可以避免创建一个新的命名方法,从而减少了代码的复杂度。
4. 匿名方法的应用场景匿名方法在许多场景下都可以使用,下面我们就来看几个典型的应用场景。
(1)事件处理程序在 Windows 应用程序中,我们经常需要为控件添加事件处理程序。
匿名方法可以方便地创建一个简单的回调函数,如下所示:```csharpbutton1.Click += delegate(object sender, EventArgs e){MessageBox.Show("Button clicked");};```这里,我们使用匿名方法来创建一个按钮单击事件的回调函数,并在回调函数中显示一个消息框。
lambdaquery用法
lambdaquery用法
LambdaQuery是一种基于Lambda表达式的查询工具,它可以帮
助我们更方便地进行LINQ查询和筛选数据。
使用LambdaQuery时,我们需要首先引入相关的命名空间:
`using LambdaQuery;`。
然后我们可以使用Lambda表达式来进行查询。
比如,我们有一个List对象,其中包含一些Person对象,每个Person对象都有Name和Age属性,我们想要查询年龄大于20的人: ```csharp
List<Person> people = new List<Person>(); // 假设已经有
一些Person对象
List<Person> results = people.Where(p => p.Age >
20).ToList(); // 使用LambdaQuery进行查询
```
这样我们就可以得到符合条件的Person对象列表了。
LambdaQuery还支持其他的查询操作,比如`OrderBy`、`GroupBy`、`Select`等等,具体的用法可以参考官方文档。
总之,LambdaQuery是一个非常方便的查询工具,可以让我们更快速地查询和筛选数据,提高开发效率。
- 1 -。
匿名方法的原理及应用
匿名方法的原理及应用1. 什么是匿名方法匿名方法是指在编程语言中,允许我们在不定义具体方法名的情况下,直接将方法作为参数传递给其他方法的一种技术。
2. 匿名方法的原理匿名方法的原理是基于委托(Delegate)的机制。
在编程语言中,委托是一种特殊的类型, 它可以持有对方法(函数)的引用。
我们可以将委托看作是一个包装了方法的对象。
通过委托,我们可以将方法作为参数进行传递,从而实现匿名方法。
3. 匿名方法的语法格式在大多数编程语言中,匿名方法的语法格式如下所示:delegate (参数列表) {// 方法体}其中,delegate关键字表示定义委托类型,参数列表用于指定方法的参数,方法体则是具体的实现。
4. 匿名方法的应用匿名方法在编程中有着广泛的应用,下面列举了几个常见的应用场景:4.1 事件处理程序匿名方法常用于事件处理程序中。
在使用匿名方法作为事件处理程序时,我们无需定义额外的方法,可以直接将方法逻辑写在事件的定义中,减少了代码的冗余。
4.2 异步编程匿名方法可以用于异步编程。
通过委托和匿名方法,我们可以将需要在异步任务完成后执行的代码直接传递给异步方法作为参数,从而实现灵活且高效的异步编程。
4.3 LINQ查询语句匿名方法可以用于LINQ查询语句中。
在LINQ查询语句中,我们经常需要指定一些过滤条件、排序方式等。
通过使用匿名方法,我们可以直接将这些逻辑写在查询语句中,使代码更加简洁和易读。
4.4 回调函数匿名方法可以作为回调函数使用。
在一些需要在完成某个任务后执行回调函数的场景中,我们可以直接将匿名方法传递给需要回调的方法,从而实现回调逻辑的灵活性。
5. 匿名方法与Lambda表达式的关系匿名方法与Lambda表达式是相关的概念,在某些编程语言中可以相互替代使用。
Lambda表达式是在匿名方法的基础上进行的扩展,它提供了更加简洁的语法格式,使得匿名方法的书写更加便捷。
Lambda表达式的语法格式如下所示:(参数列表) => {// 方法体}其中,=>是Lambda运算符,将参数列表和方法体分隔开来。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
进行以下转换的前提是此处 x 的数据类型 可以根据上下文推断出来 (int x) => {return x+1;}
x => {return x+1;}
Lambda表达式的简写方式
如果方法体只包含一条语句时
(参数列表) => {方法体}
(参数列表) => 表达式
(int x) => {return x+1;}
(int x) => x+1
Lambda表达式的更多例子
多参数,推断类型参数列 表,表达式方法体 (x, y) => x * y 无参数,表达式方法体 () => Console.WriteLine()
(x, y) => { Console.WriteLine( x ); Console.WriteLine( y ); }
LNIQ to Objects LINQ to LINQ to XML
<book> <title/> <author/> <year/> <price/> </book>
Objects
Relational
XML
LINQ 初体验
在没有LINQ以前,我们这样查询:
int[] numbers = new int[] { 6, 4, 3, 2, 9, 1, 7, 8, 5 }; List<int> even = new List<int>(); foreach (int number in numbers) { if (number % 2 == 0) { even.Add(number); } } even.Sort(); even.Reverse();
从 numbers 数组中提取 偶数并降序排列
演示示例:Hello, LINQ
代码分析
int[] numbers = new int[] { 6, 4, 3, 2, 9, 1, 7, 8, 5 }; 推断类型
var even = numbers .Where( p => p % 2 == 0 ) .Select( p => p ) .OrderByDescending( p => p ); 扩展方法
SQL 编码体验落后
没有智能感应 没有严格意义上的强类型和类型检查
SQL 和 XML 都有各自的查询语言,而对象没有自己的查 询语言
LINQ是什么
LINQ( Language Integrated Query )即语言集成查询 LINQ 是一组语言特性和API,使得你可以使用统一的方式 编写各种查询。查询的对象包括XML、对象集合、SQL Server 数据库等等。 LINQ 主要包含以下三部分:
LINQ to Objects 主要负责对象的查询 LINQ to XML 主要负责 XML 的查询 LINQ to 主要负责数据库的查询
LINQ to SQL LINQ to DataSet VB Others…
.NET Language Integrated Query
说明 Where方法也是一个泛型扩展方法 它和 Select() 一样作用于IEnumerable<TSource>类型 它只接受一个 Func<TSource, bool> 泛型委托参数 在这里 predicate 是一个判断条件
Where() 例子
var q2 = persons .Where(person => .StartsWith("涛")) .Select(person => .ToLower()); foreach (var item in q2) { Console.WriteLine(item); }
演示示例:Lambda表达式的使用
Lambda表达式语法
最基本的 Lambda 表达式语法如下:
(参数列表) => {方法体}
说明 参数列表中的参数类型可以是明确类型或者是推断 类型 如果是推断类型,则参数的数据类型将由编译器根 据上下文自动推断出来
Lambda表达式的简写方式
如果参数列表只包含一个推断 (类型参数时 参数列表) => {方法体}
演示示例:Select方法示例
基本查询操作符-过滤数据
Where()
public static IEnumerable<TSource> Where<TSource>( this IEnumerable<TSource> source, Func<TSource, bool> predicate )
???
Lambda 表达式的进化
C# 3.0
Lambda 表达式
C# 2.0
匿名方法
C# 1.0
委托
匿名方法
在 C# 2.0 中,加入了匿名方法特性:
参数列表
方法体
// 匿名方法方式 ProcessString p = delegate( string input ) { return input.ToLower(); 注意: 这里没有了具体 }; 的方法名称 因此称为匿 foreach (string name in list) 名方法 { Console.WriteLine( p ( name ) ) ; }
添加一些数据
List<Person> persons = new List<Person>(); persons.Add(new Person { Pid = 1, Name = "花痴瑶", Cid = 2}); persons.Add(new Person { Pid = 2, Name = "涛大雕", Cid = 1}); persons.Add(new Person { Pid = 3, Name = "唐三雕", Cid = 2 }); persons.Add(new Person { Pid = 4, Name = "安琪", Cid = 2 }); persons.Add(new Person { Pid = 5, Name = "彪彪哥", Cid = 2 }); persons.Add(new Person { Pid = 5, Name = "彪夫人", Cid = 3 }); persons.Add(new Person { Pid = 7, Name = "彭博导", Cid = 1 }); persons.Add(new Person { Pid = 8, Name = "涛叫兽", Cid = 1 }); persons.Add(new Person { Pid = 9, Name = "Pork Rong", Cid = 2 }); List<Class> classes = new List<Class>(); classes.Add(new Class { Cid = 1, Name = "网络1班" }); classes.Add(new Class { Cid = 2, Name = "软件2班" }); classes.Add(new Class { Cid = 3, Name = "会计3班" }); classes.Add(new Class { Cid = 4, Name = "电子4班" });
演示示例:匿名方法的使用
Lambda 表达式
在 C# 3.0 中,继匿名方法之后加入了更为简洁的 Lambda 表达式:
// Lambda 表达式方式 ProcessString p = input => input.ToLower(); foreach (string name in list) { Console.WriteLine( p ( name ) ) ; }
OrderBy() 例子
排序字段,这里指定按照姓名的 第二个字母升序排列
var q3 = persons .Where(person => .Length > 2) .Select(person => .ToLower()) .OrderBy(name => name.Substring(1, 1)); foreach (var item in q3) { Console.WriteLine(item); }
Select() 例子
以 Lambda 表达式形式出现的 Func<TSource, TResult>委托实例 var q1 = persons.Select(person => ()); foreach (var item in q1) { Console.WriteLine(item); }
创建两个实体类
public class Class{ int cid; string name; public int Cid { get {return cid; } set {cid = value;} } public string Name { get {return name;} set { name = value; } } } public class Person { int pid; string name; int cid; public string Name { get { return name; } set { name = value; } } public int Pid { get { return pid; } set { pid = value; } } public int Cid { get { return cid; } set { cid = value; } } }