初探Linq表达式和lambda表达式

最新推荐文章于 2023-12-15 00:09:12 发布
最新推荐文章于 2023-12-15 00:09:12 发布
阅读量496 收藏
点赞数
分类专栏： C#基础类

【Linq表达式】

         LINQ，语言集成查询（LanguageIntegrated Query）是一组用于c#和Visual BasiC语言的扩展。它允许编写C#或者VisualBasic代码以查询数据库相同的方式操作内存数据。

        博主认为，Linq表达式在用法方面就是SQL语句的变形，只要将SQL语句按照执行顺序来重新编写就可以得到Linq表达式。

【Lambda表达式】

        Lambda 用在基于方法的 LINQ查询中，对网上查询到的关于Lambda表达式的资料不甚了解。Lambda表达式的使用在C#中，Lambda 表达式都使用 Lambda 运算符 =>，该运算符读为“goes to”。

        博主认为：Lambda用于Linq查询中，Lambda表达式就是用Lambda语法将Linq表达式表示出来。

       下面用几个语句对Linq表达式和Lambda表达式进行区别，为了便于理解，每个例子都以SQL语句、Linq表达式、Lambda表达式三种形式呈现。

1.简单的查询

[csharp] view plain copy
print ?
  1. //1——Linq表达式  
  2. var ss = from r in db.Am_recProScheme  
  3.          select r;  
  4. //2——Lambda表达式  
  5. var ss1 = db.Am_recProScheme;  
  6. //3——SQL语句  
  7. string sssql = "select * from Am_recProScheme";  
//1——Linq表达式
var ss = from r in db.Am_recProScheme
         select r;
//2——Lambda表达式
var ss1 = db.Am_recProScheme;
//3——SQL语句
string sssql = "select * from Am_recProScheme";
2.带where的查询

[csharp] view plain copy
print ?
  1. //1  
  2. var ss = from r in db.Am_recProScheme  
  3.          where r.rpId > 10  
  4.          select r;  
  5. //2  
  6. var ss1 = db.Am_recProScheme.Where(p => p.rpId > 10);  
  7. //3  
  8. string sssql = "select * from Am_recProScheme where rpid>10";  
//1
var ss = from r in db.Am_recProScheme
         where r.rpId > 10
         select r;
//2
var ss1 = db.Am_recProScheme.Where(p => p.rpId > 10);
//3
string sssql = "select * from Am_recProScheme where rpid>10";
3.简单的函数计算（count，min，max，sum）
[csharp] view plain copy
print ?
  1. //1  
  2. 获取最大的rpId  
  3. //var ss = (from r in db.Am_recProScheme  
  4. //          select r).Max(p => p.rpId);  
  5. 获取最小的rpId  
  6. //var ss = (from r in db.Am_recProScheme  
  7. //          select r).Min(p => p.rpId);  
  8. //获取结果集的总数  
  9. //var ss = (from r in db.Am_recProScheme                    
  10. //         select r).Count();  
  11. //获取rpId的和  
  12. var ss = (from r in db.Am_recProScheme  
  13.          select r).Sum(p => p.rpId);  
  14.   
  15.   
  16. //2  
  17. //var ss1 = db.Am_recProScheme.Max(p=>p.rpId);  
  18. //var ss1 = db.Am_recProScheme.Min(p => p.rpId);  
  19. //var ss1 = db.Am_recProScheme.Count() ;  
  20. var ss1 = db.Am_recProScheme.Sum(p => p.rpId);  
  21. Response.Write(ss);  
  22.   
  23. //3  
  24. string sssql = "select max(rpId) from Am_recProScheme";  
  25.        sssql = "select min(rpId) from Am_recProScheme";  
  26.        sssql = "select count(1) from Am_recProScheme";  
  27.        sssql = "select sum(rpId) from Am_recProScheme";  
//1
获取最大的rpId
//var ss = (from r in db.Am_recProScheme
//          select r).Max(p => p.rpId);
获取最小的rpId
//var ss = (from r in db.Am_recProScheme
//          select r).Min(p => p.rpId);
//获取结果集的总数
//var ss = (from r in db.Am_recProScheme                  
//         select r).Count();
//获取rpId的和
var ss = (from r in db.Am_recProScheme
         select r).Sum(p => p.rpId);


//2
//var ss1 = db.Am_recProScheme.Max(p=>p.rpId);
//var ss1 = db.Am_recProScheme.Min(p => p.rpId);
//var ss1 = db.Am_recProScheme.Count() ;
var ss1 = db.Am_recProScheme.Sum(p => p.rpId);
Response.Write(ss);

//3
string sssql = "select max(rpId) from Am_recProScheme";
       sssql = "select min(rpId) from Am_recProScheme";
       sssql = "select count(1) from Am_recProScheme";
       sssql = "select sum(rpId) from Am_recProScheme";
4.排序order by desc/asc
[csharp] view plain copy
print ?
  1. var ss = from r in db.Am_recProScheme  
  2.          where r.rpId > 10  
  3.          orderby r.rpId descending  //倒序  
  4.          //  orderby r.rpId ascending   //正序  
  5.          select r;  
  6.   
  7. //正序  
  8. var ss1 = db.Am_recProScheme.OrderBy(p => p.rpId).Where(p => p.rpId > 10).ToList();  
  9. //倒序  
  10. var ss2 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).ToList();  
var ss = from r in db.Am_recProScheme
         where r.rpId > 10
         orderby r.rpId descending  //倒序
         //  orderby r.rpId ascending   //正序
         select r;

//正序
var ss1 = db.Am_recProScheme.OrderBy(p => p.rpId).Where(p => p.rpId > 10).ToList();
//倒序
var ss2 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).ToList();
[csharp] view plain copy
print ?
  1. <span style="font-family: Calibri; font-size: 18.6667px;">string sssql = "select * from Am_recProScheme where rpid>10 order by rpId [desc|asc]";</span>  
<span style="font-family: Calibri; font-size: 18.6667px;">string sssql = "select * from Am_recProScheme where rpid>10 order by rpId [desc|asc]";</span>
5.top(1)

[csharp] view plain copy
print ?
  1. //1 如果取最后一个可以按倒叙排列再取值  
  2. var ss = (from r in db.Am_recProScheme                       
  3.          select r).FirstOrDefault();  
  4.   
  5. //2 linq to ef 好像不支持 Last()   
  6. var ss1 = db.Am_recProScheme.FirstOrDefault();  
  7. //var ss1 = db.Am_recProScheme.First();            
  8. //3   
  9. string sssql = "select top(1) * from Am_recProScheme";  
//1 如果取最后一个可以按倒叙排列再取值
var ss = (from r in db.Am_recProScheme                     
         select r).FirstOrDefault();

//2 linq to ef 好像不支持 Last() 
var ss1 = db.Am_recProScheme.FirstOrDefault();
//var ss1 = db.Am_recProScheme.First();          
//3 
string sssql = "select top(1) * from Am_recProScheme";
6.跳过前面多少条数据取余下的数据
[csharp] view plain copy
print ?
  1. //1  
  2. var ss = (from r in db.Am_recProScheme  
  3.          orderby r.rpId descending  
  4.          select r).Skip(10); //跳过前10条数据，取10条之后的所有数据     
  5. //2    
  6. var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Skip(10).ToList();  
  7. //3  
  8. string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10";  
//1
var ss = (from r in db.Am_recProScheme
         orderby r.rpId descending
         select r).Skip(10); //跳过前10条数据，取10条之后的所有数据   
//2  
var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Skip(10).ToList();
//3
string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10";
7.分页数据查询
[csharp] view plain copy
print ?
  1. //1  
  2. var ss = (from r in db.Am_recProScheme  
  3.          where r.rpId > 10  
  4.          orderby r.rpId descending  
  5.          select r).Skip(10).Take(10); //取第11条到第20条数据                     
  6.   
  7. //2 Take(10): 数据从开始获取，获取指定数量（10）的连续数据  
  8. var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).Skip(10).Take(10).ToList();  
  9. //3  
  10. string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10 and rowNum<=20";  
//1
var ss = (from r in db.Am_recProScheme
         where r.rpId > 10
         orderby r.rpId descending
         select r).Skip(10).Take(10); //取第11条到第20条数据                   

//2 Take(10): 数据从开始获取，获取指定数量（10）的连续数据
var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).Skip(10).Take(10).ToList();
//3
string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10 and rowNum<=20";
8.包含，类似like '%%'
[csharp] view plain copy
print ?
  1. //1  
  2. var ss = from r in db.Am_recProScheme  
  3.          where r.SortsText.Contains("张")  
  4.          select r;  
  5. //2  
  6. var ss1 = db.Am_recProScheme.Where(p => p.SortsText.Contains("张")).ToList();  
  7. //3  
  8. string sssql = "select * from Am_recProScheme where SortsText like '%张%'";  
//1
var ss = from r in db.Am_recProScheme
         where r.SortsText.Contains("张")
         select r;
//2
var ss1 = db.Am_recProScheme.Where(p => p.SortsText.Contains("张")).ToList();
//3
string sssql = "select * from Am_recProScheme where SortsText like '%张%'";
9.分组group by
[csharp] view plain copy
print ?
  1. //1  
  2. var ss = from r in db.Am_recProScheme  
  3.          orderby r.rpId descending  
  4.          group r by r.recType into n  
  5.          select new  
  6.          {  
  7.                 n.Key,  //这个Key是recType  
  8.                 rpId = n.Sum(r => r.rpId), //组内rpId之和  
  9.                 MaxRpId = n.Max(r => r.rpId),//组内最大rpId  
  10.                 MinRpId = n.Min(r => r.rpId), //组内最小rpId  
  11.           };  
  12. foreach (var t in ss)  
  13. {  
  14.        Response.Write(t.Key + "--" + t.rpId + "--" + t.MaxRpId + "--" + t.MinRpId);  
  15. }  
  16. //2  
  17. var ss1 = from r in db.Am_recProScheme  
  18.           orderby r.rpId descending  
  19.           group r by r.recType into n  
  20.           select n;  
  21. foreach (var t in ss1)  
  22. {  
  23.         Response.Write(t.Key + "--" + t.Min(p => p.rpId));  
  24. }  
  25. //3  
  26. var ss2 = db.Am_recProScheme.GroupBy(p => p.recType);  
  27. foreach (var t in ss2)  
  28. {  
  29.         Response.Write(t.Key + "--" + t.Min(p => p.rpId));  
  30. }  
  31. //4  
  32. string sssql = "select recType,min(rpId),max(rpId),sum(rpId) from Am_recProScheme group by recType";  
//1
var ss = from r in db.Am_recProScheme
         orderby r.rpId descending
         group r by r.recType into n
         select new
         {
                n.Key,  //这个Key是recType
                rpId = n.Sum(r => r.rpId), //组内rpId之和
                MaxRpId = n.Max(r => r.rpId),//组内最大rpId
                MinRpId = n.Min(r => r.rpId), //组内最小rpId
          };
foreach (var t in ss)
{
       Response.Write(t.Key + "--" + t.rpId + "--" + t.MaxRpId + "--" + t.MinRpId);
}
//2
var ss1 = from r in db.Am_recProScheme
          orderby r.rpId descending
          group r by r.recType into n
          select n;
foreach (var t in ss1)
{
        Response.Write(t.Key + "--" + t.Min(p => p.rpId));
}
//3
var ss2 = db.Am_recProScheme.GroupBy(p => p.recType);
foreach (var t in ss2)
{
        Response.Write(t.Key + "--" + t.Min(p => p.rpId));
}
//4
string sssql = "select recType,min(rpId),max(rpId),sum(rpId) from Am_recProScheme group by recType";
10.连接查询
[csharp] view plain copy
print ?
  1. //1  
  2. var ss = from r in db.Am_recProScheme  
  3.          join w in db.Am_Test_Result on r.rpId equals w.rsId  
  4.          orderby r.rpId descending  
  5.          select r;  
  6. //2  
  7. var ss1 = db.Am_recProScheme.Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).OrderByDescending(p => p.rpId).ToList();  
  8. //3  
  9. string sssql = "select r.* from  [Am_recProScheme] as r inner join [dbo].[Am_Test_Result] as t on r.[rpId] = t.[rsId] order by r.[rpId] desc";  
//1
var ss = from r in db.Am_recProScheme
         join w in db.Am_Test_Result on r.rpId equals w.rsId
         orderby r.rpId descending
         select r;
//2
var ss1 = db.Am_recProScheme.Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).OrderByDescending(p => p.rpId).ToList();
//3
string sssql = "select r.* from  [Am_recProScheme] as r inner join [dbo].[Am_Test_Result] as t on r.[rpId] = t.[rsId] order by r.[rpId] desc";
11.sql中的In
[csharp] view plain copy
print ?
  1. //1——Linq  
  2. var ss = from p in db.Am_recProScheme  
  3.          where (new int?[] { 24, 25,26 }).Contains(p.rpId)  
  4.          select p;  
  5. foreach (var p in ss)  
  6. {  
  7.        Response.Write(p.Sorts);  
  8. }  
  9. //2——SQL  
  10. string st = "select * from Am_recProScheme where rpId in(24,25,26)";  
Andrewniu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Lambda表达式与LINQ.rar
03-30
Lambda表达式与LINQ.rar Lambda表达式与LINQ.rar Lambda表达式与LINQ.rar
什么是Linq表达式什么是Lambda表达式.pdf
04-02
什么是Linq表达式什么是Lambda表达式.pdf 什么是Linq表达式什么是Lambda表达式.pdf
Linq表达式、Lambda表达式你更喜欢哪个？
weixin_30782331的博客
06-21 287
阅读目录 什么是Linq表达式？什么是Lambda表达式？ 查询表达式、点标记你更喜欢哪个？ 为什么选择点标记 什么时候使用查询表达式？ 联接查询（内联、左联、交叉联） 总结： 什么是Linq表达式？什么是Lambda表达式？ 如图： 由此可见Linq表达式和Lamdba表达式并没有什么可比性...
linq表达式对比lambda表达式
Vincent_yuan1991的博客
03-22 642
什么是Linq表达式？什么是Lambda表达式？ 前一段时间用到这个只是，在网上也没找到比较简单明了的方法，今天就整理了一下相关知识，有空了再仔细研究研究 public Program() { List&lt;Student&gt; allStudent = new List&lt;Student&gt; { new Student("张三",23), new Student("李四",2...
EF core 中用lambda表达式和Linq的一些区别
abxdd2015的博客
08-29 663
转眼一看，又过了10几天没有写博客了，主要还是没有什么可以写的，因为遇到的问题都不是很有价值。不过最近发现用lambda表达式，比用Linq的代码量会少一些，而且也方便一些。不过两者都差不多，相差不是特别大。 在EF core中，表和表之中都有对应的关系，例如一对一，一对多，还有多对多。要实现一对一，一对多加上主外键，实现多对多则需要加上一个中间表，这样结构清晰，维护也非常的方便。 ...
C# Linq lambda表达式.doc
11-06
在C#中，Lambda表达式是LINQ的核心部分，它用于创建匿名函数，使得我们可以更加便捷地进行过滤、查找、排序、分组等操作。 1. **过滤（Filtering）** 在C#中，我们可以使用Lambda表达式配合`Where()`方法来过滤...
C#高级编程_Lambda表达式和LINQ的原理和使用
07-09
在C#编程中，Lambda表达式和LINQ是两种强大的工具，它们极大地简化了代码的编写，特别是处理数据查询和事件处理。理解这两者的工作原理和使用方式是成为C#高级程序员的关键步骤。 Lambda表达式是匿名函数的一种简洁...
理解C#中的Lambda表达式
09-03
Lambda表达式在C#中扮演着重要角色，特别是在LINQ（Language Integrated Query）和其他异步编程场景中。下面我们将深入探讨Lambda表达式的特性、用法以及与匿名方法的关系。 1. **Lambda表达式的基本形式** Lambda...
动态构建Linq表达式
04-11
`Building-Linq-Expressions-Dynamically.pdf`可能是详细讲解动态构建Linq表达式的教程文档，而`RequestEngineTest.zip`可能包含了一个演示如何动态构建和执行Linq表达式的测试项目。通过阅读文档和运行示例代码，你...
C#知识体系（一）常用的LINQ与Lambda表达式.pdf
04-02
C#知识体系（一）常用的LINQ与Lambda表达式.pdf C#知识体系（一）常用的LINQ与Lambda表达式.pdf
超级全面的Linq语法、SQL语法、lambda表达式对照(相同功能的不同于法)
04-25
很有价值的文档学习语法指南。。。 sql语句-linq语言-lambda表达式对照。 超级全面的Ling语法、SQL语法、lambda表达式对照(相同功能的不同于法)、 可以帮助对SQL、linq、lambda表达式存在疑惑不明白的在这里面可以充分提现出来语法间的对比和学习。让你逐渐对linq、lambda表达式有了解甚至使用。。。
LINQ和Lambda表达式
diaoyu3131的博客
07-20 130
前言 前段时间接触了一种新的表达式，但是不知道这个是什么意思，所以就先站在巨人的肩膀用了，现在听师哥说这种写法是Lambda表达式。我一直以为，这个Lambda表达式和LINQ查询有异曲同工之妙，可惜，这样想就大错特错了。 内容 LINQ表达式 定义 语言集成查询（Language Integrated Query），允许编写C#或者VB代码以查询数据库...
lambda和linq对比
weixin_40719943的博客
12-05 5580
相关：https://www.cnblogs.com/zhaopei/p/5746414.html using System; using System.Collections.Generic; using System.Linq; namespace LinqTest { public class Person { public i...
sql 、linq、lambda 总结
weixin_33812433的博客
04-01 247
LINQ的书写格式如下： 　　from 临时变量 in 集合对象或数据库对象 　　where 条件表达式 　　[order by条件] 　　select 临时变量中被查询的值 　　[group by 条件] Lambda表达式的书写格式如下： (参数列表) =&gt; 表达式或者语句块 其中： 参数个数：可以有多个参数，一个参数，或者无参数。 参数类型：可以隐式或者显式定义。 表达式或者...
LINQ与Lambda表达式
WHYFAST的专栏
07-09 837
LINQ（Language-integrated Query） 是微软提出的一项新技术 ，能将查询功能直接引入到.net framwork所支持的编程语言中。查询操作可以通过编程语言自身来传达，而不用以字符串形式嵌入到代码中。 LINQ 主要包括LINQ to SQL，LINQ to DataSet，LINQ to Objects和LINQ to XML4种技术。 VAR 在c#后期...
Lambda表达式和linq普通语法的一些对比
bulote
01-22 78
linq普通语法 return (from p in dc.TeacherBasicInformation where p.TeacherNum == num select p.PhotoSrc).FirstOrDefault();&lt;wbr&gt;&lt;wbr&gt;&lt;wbr&gt;&lt;wbr&gt;&lt;wbr&gt;&lt;wbr&gt;&lt;wbr&gt;&
Lambda 与 linq 区别
autumn20080101的专栏
09-25 1201
Lambda 与 linq 区别 1 悬赏园豆：20 [已解决问题] 浏览: 6668次 我想问一下 Lambda 与 linq 区别 是什么？ C# linq Lambda sunjie | 初学一级 | 园豆：131 提问于：2012-04-20 09:27 > 找找看 收藏 最佳答
在C#中，LINQ语句和Lambda表达式有什么不同？
最新发布
贪嗔痴念 世人皆是
12-15 674
表达式在 C# 中都是处理集合数据的有效工具，选择使用哪种方式取决于具体的需求和场景。（Language Integrated Query）语句和。表达式适用于简单的条件筛选或数据处理。语句更适合复杂的查询和操作，而。
LINQ表达式详解
05-26
LINQ（Language Integrated Query）是一种在.NET Framework中引入的查询语言，它可以通过统一的语法和语义查询各种数据源，包括对象、XML、SQL数据库以及其他数据源。 LINQ表达式是LINQ中的一种查询方式，它是一种基于Lambda表达式的查询方式，可以将查询条件和查询结果定义为表达式树，然后通过表达式树转换器将表达式树转换为对应的查询语言，如SQL语句。 LINQ表达式的语法和Lambda表达式非常类似，它由三个主要部分组成： 1. From子句：指定要查询的数据源。 2. Where子句：指定查询条件。 3. Select子句：指定查询结果。 例如，下面的LINQ表达式查询一个整数列表中大于5的数字，并返回它们的平方： ``` List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var result = from n in numbers where n > 5 select n * n; ``` 在上面的示例中，`from n in numbers`指定了数据源为`numbers`列表，`where n > 5`指定了查询条件为大于5的数字，`select n * n`指定了查询结果为数字的平方。 除了基本的查询操作，LINQ表达式还支持一系列其他的操作，如排序、分组、连接、聚合等。这些操作可以通过不同的语法结构来实现，使得LINQ表达式具有非常强大的查询能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值