1. Toy模板网首页
  2. > Toy博客

C# LINQ和Lambda表达式对照

9月前 作者：YSの陈憨憨 分类：Toy博客 阅读(36) 违法举报

这篇具有很好参考价值的文章主要介绍了C# LINQ和Lambda表达式对照。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

C# LINQ和Lambda表达式对照

1. 基本查询语句

Linq语法：

var data=from a in db.Areas select a ;

Lamda语法：

var data=db.Areas;

sql语法：

SELECT * FROM Areas

2. 简单的WHERE语句

Linq语法：

var data=from a in db.orderInfo where a.orderId > 20 select a ;

Lamda语法：

var data=db.orderInfo.Where( t=>t.orderId > 20 ) ;

sql语法：

SELECT * FROM orderInfo WHERE orderId > 20

3. 关于“COUNT、SUM、MIN、MAX”函数的语句

Linq语法：

//查询该表中最大编号Id  
var data=( from a in db.orderInfo select a ).Max( p=>p.orderId ) ;

//查询该表中最小编号Id  
var data=( from a in db.orderInfo select a ).Min( p=>p.orderId ) ;

//查询该表数据总条数  
var data=( from a in db.orderInfo select a ).Count() ;

//查询该表中所有消费额的总数（求和）
var data=( from a in db.orderInfo select a ).Sum( p=>p.orderMoney ) ;

Lamda语法：

//查询该表中最大编号Id  
var data=db.orderInfo.Max( t=>t.orderId );

//查询该表中最小编号Id 
var data=db.orderInfo.Min( t=>t.orderId ); 

//查询该表数据总条数  
var data=db.orderInfo.Count();

//查询该表中所有消费额的总数（求和） 
var data=db.orderInfo.Sum( t=>t.orderMoney);

sql语法：

SELECT MAX(orderId) FROM orderInfo

SELECT MIN(orderId) FROM orderInfo

SELECT COUNT(*) FROM orderInfo

SELECT SUM(orderMoney ) FROM orderInfo

​

4. 关于数据排序的语句

Linq语法：

//倒序排序，升序可用ascending关键字  
var data=from a in db.orderInfo 
    where a.orderId > 20 
    orderby a.orderId descending 
    select a ;

Lamda语法：

//情况一，根据单字段排序：  
//倒序排序，升序可用OrderBy关键字
var data=db.orderInfo.OrderByDescending( t=>t.orderId ).
    Where( t=>t.orderId > 20 ).
    ToList();  

//情况二，根据多字段主次排序：  
//先按年升序，再按月升序  
var priceMonthEntities = priceMonthApp.GetList().
    OrderBy(t => t.F_Year).
    ThenBy(t => t.F_Month).ToList();

sql语法：

//倒序排序，升序可用ASC关键字
SELECT * FROM orderInfo WHERE orderId > 20 ORDER BY orderId DESC

​

5. 关于分页查询的语句

Linq语法：

var data=( from a in db.orderInfo select a ).
    Skip((pageIndex-1) * pageSize).
    Take(pageSize).
    ToList();

Lamda语法：

//pageIndex:当前页码，pageSize：分页数据显示条数  
var data=db.orderInfo.Skip((pageIndex-1)* pageSize).Take(pageSize).ToList();

sql语法：

SELECT TOP pageSize * FROM orderInfo 
WHERE orderId NOT IN(SELECT TOP( ( pageIndex - 1) * pageSize) orderId FROM orderInfo)

​

6. 关于模糊查询（like）的语句

Linq语法：

//使用Contains关键字进行模糊匹配  
var data= from a in db.orderInfo 
    where a.orderId.Contains(1) 
    select a;

Lamda语法：

//使用Contains关键字进行模糊匹配  
var data=db.orderInfo.Where(t=>t.F_UserId.Contains("1")).ToList();

sql语法：

//使用like关键字进行模糊匹配  
SELECT * FROM orderInfo WHERE orderId LIKE '%12%'

7. 关于分组查询的语句

Linq语法：

var data= from a in db.orderInfo 
    orderby a.orderId descending   
    group a by a.orderType into s select new{  
        s.key,//分组字段  
        s.sMoney=s.Sum(a=>a.orderMoney),//分组后算出总的消费额  
        s.maMoney=s.Max(a=>a.orderMoney),//分组后算出最大的消费额  
        s.miMoney=s.Min(a=>a.orderMoney)//分组后算出最小的消费额  
    };

Lamda语法：

//使用GroupBy关键字进行分组查询（单个字段）  
var data=db.orderInfo.GroupBy(p => p.recType).
    Select(t=>t.Key).ToList();  

//使用GroupBy关键字进行分组查询（多个字段）  
var data=db.orderInfo.GroupBy(p =>new{ p.recType,p.orderId}).
    Select(t=>new{ 
        recType=t.Key.recType,
        orderId=t.Key.orderId
    }).ToList();

sql语法：

SELECT orderType , SUM(orderMoney), MAX(orderMoney), MIN(orderMoney) 
FROM orderInfo GROUP BY orderType

​

8. 关于多表关联查询的语句

Linq语法：

//使用join关键字进行表连接  
var data= from a in db.orderInfo 
    join e in db.orderType on a.orderTypeId equals e.id 
    select r ;   

var query=from t in db.orderInfo 
    join s in db.orderType on t.orderTypeId equals s.id 
    select new {  
        orderId=t.id,  
        orderTypeName=s.name,  
        ...  
    }

Lamda语法：

var data=db.orderInfo.Join(db.orderType,t=>t.orderTypeId,s=>s.id,(t,s)=>t).
    OrderByDescending(t=>t.orderId).  
    Select(  
    t=> new{  
        orderId=t.t.id,  
        orderTypeName=t.s.name,  
        ...  
    }).ToList(); //使用Join关键字进行表连接

EF Core中的写法：

var data=db.orderInfo.Join(db.orderType,t=>t.orderTypeId,s=>s.id,(t,s)=>new{  
    orderId=s.Id,  
    .....  
}).toList();

sql语法：（sql语句表关联有多种方法，在此只举一例）

SELECT * FROM orderInfo o ,orderType t 
WHERE o.orderTypeId=t.id ORDER BY t.createDate

​

9. 关于in查询的语句

Linq语法：

var data= from a in db.orderInfo 
    where (new int?[2213,43311,32422]).Contains(a.orderId) 
    select a ;

Lamda语法：

var data=db.orderInfo.Where(t=>(new int?[2213,43311,32422]).Contains(t.orderId)).ToList();

sql语法：

SELECT * FROM orderInfo WHERE orderId IN (2213,43311,32422)

10. 关于去重查询的语句

Linq语法：

//使用group关键字进行表数据去重  
var data= from a in db.orderInfo 
    group p by new {a.orderTypeId} into _group 
    select _group.FirstOrDefault(); 

//使用group关键字对多个字段进行表数据去重  
var data= from a in db.orderInfo 
    group p by new {a.orderTypeId,...} into _group 
    select _group.FirstOrDefault();

Lamda语法：

//单个去重：  
// 使用GroupBy关键字进行表数据去重  
var data=db.orderInfo.GroupBy(t=>t.orderTypeId).Select(r => r.First()).ToList(); 

// 使用DistinctBy关键字进行表数据去重  
var data=db.orderInfo.DistinctBy(t=>t.orderTypeId).ToList(); 

//多个字段去重：  
// 使用GroupBy关键字对多个字段进行表数据去重  
var data=db.orderInfo.GroupBy(t=>new{t.orderTypeId,...}).Select(r => r.First()).ToList(); 

// 使用DistinctBy关键字对多个字段进行表数据去重  
var data=db.orderInfo.DistinctBy(t=>new{t.orderTypeId,...}).ToList();

sql语法：

-- 使用DISTINCT关键字进行表数据去重  
SELECT DISTINCT orderTypeId  FROM orderInfo

-- 使用GROUP BY关键字进行表数据去重 
SELECT orderTypeId FROM orderInfo GROUP BY orderTypeId

11. 内连接 INNER JOIN

Linq语法：

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;

Lamda语法：

var ss1 = db.Am_recProScheme.
    Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).
    OrderByDescending(p => p.rpId).ToList();

sql语法：

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 JOIN

要求：两个DataTable关联，查找只在第一个表中的数据

DataTable dt1 = new DataTable("Ta");  
DataTable dt2 = new DataTable("Tb");  
dt1.Columns.Add("ID", typeof(int));  
dt1.Columns.Add("Name", typeof(string));  
dt1.Rows.Add(1, "小明");  
dt1.Rows.Add(2, "小红");  
dt1.Rows.Add(3, "小黑");  
dt2.Columns.Add("ID", typeof(int));  
dt2.Columns.Add("Name", typeof(string));  
dt2.Rows.Add(1, "小黄");  
dt2.Rows.Add(2, "小红");  
dt2.Rows.Add(3, "小强");

Linq语法：

var query = from q1 in dt1.AsEnumerable()  
    join q2 in dt2.AsEnumerable()  
    on q1.Field<string>("Name") equals q2.Field<string>("Name") into tmp  
    from q3 in tmp.DefaultIfEmpty()  
    where q3 == null  
    select new {  
        ID = q1.Field<int>("ID"),  
        Name = q1.Field<string>("Name")  
    };

Lamda语法 ：

var query = dt1.AsEnumerable().GroupJoin(  
        dt2.AsEnumerable(),  
        x => x.Field<string>("Name"),  
        y => y.Field<string>("Name"),  
        (x, y) => y.DefaultIfEmpty(). Where(w => w == null).  
        Select(z => new { ID = x.Field<int>("ID"), Name = x.Field<string>("Name") })  
        ).SelectMany(x => x);  
    foreach (var item in query)  
    {  
        Console.WriteLine($"ID={item.ID}    Name={item.Name}");  
    }

​

13. 三表连接

sql 语法：

SELECT id, name, jname, cname     
        FROM userinfo u     
        LEFT JOIN job j on u.job = j.jid     
        LEFT JOIN city c on u.city = c.cid

Linq语法：文章来源地址https://www.toymoban.com/news/detail-603986.html

var list = (    
    from u in dc.userinfos    
        join j in dc.jobs on u.job equals j.jid into j_join    
    from x in j_join.DefaultIfEmpty()    
        join c in dc.cities on u.city equals c.cid into c_join    
    from v in c_join.DefaultIfEmpty()    
    select new    
    {    
        id = u.id,    
        name = u.name,    
        jname = x.jname,    
        cname = v.cname,    
        /*u1=u,x1=x,v1=v*/    
        //不要用对象的方式 因为对象可能为null那么对象.属性就会抛异常    
    }    
).ToList();    

for (var i = 0; i < list.Count(); i++)    
{    
    Console.WriteLine(list[i].name + '\t' + list[i].jname + '\t' + list[i].cname); //字段为null不报异常    
    //Console.WriteLine(list[i].u1.name+'\t'+list[i].x1.jname+'\t'+list[i].v1.cname+"\r\n"); //对象x1 v1 有可能为null 抛异常    
}    
Console.ReadLine();

14. 实例用法：

//数据库 + 自定义名称 =new 数据库  
mydbDataContext con = new mydbDataContext();  

//模糊查询表达式中用.Contains  
con.car.Where(r=>r.name.Contains(TextBox1.Text.Trim())).ToList(）;  

//开头查用.StartWith  
con.car.Where(r => r.name.StartsWith(TextBox1.Text)).ToList();  

//结尾查用.EndWith  
con.car.Where(r => r.name.EndsWith(TextBox1.Text)).ToList();  

//最大值  
con.car.Max(r => r.price * r.oil).ToString();  

//最小值  
con.car.Min(r => r.price).ToString();  

//求和  
con.car.Sum(r => r.price).ToString();  

//平均值  
con.car.Average(r => r.price).ToString();  

//升序：  
con.car.OrderBy(r => r.price).ToList();  

//降序：  
con.car.OrderByDescending(r => r.price).ToList();  
  
//上一页，下一页，组合查询：  
int PageCount = 5;//每页显示条数  

//上一页，PageCount_Label.Text为当前页码  
int pageNum = Convert.ToInt32(PageCount_Label.Text) - 1;  
Repeater1.DataSource = con.car.Skip((pageNum - 1) * PageCount).Take(PageCount);  
Repeater1.DataBind();   
PageCount_Label.Text = pageNum.ToString();  

//下一页  
int pageNum = Convert.ToInt32(PageCount_Label.Text) + 1;  
Repeater1.DataSource = con.car.Skip((pageNum - 1) * PageCount).Take(PageCount);  
Repeater1.DataBind();  
PageCount_Label.Text = pageNum.ToString();  

//组合查询的点击事件  
List<car> list = con.car.ToList();  
if (TextBox2.Text != "")  
{  
    List<car> list1 = con.car.Where(r => r.name.Contains(TextBox2.Text)).ToList();  
    list = list.Intersect(list1).ToList();  
}  
if (TextBox3.Text != "")  
{  
    List<car> list1 = con.car.Where(r => r.oil == Convert.ToDecimal(TextBox3.Text)).ToList();  
    list = list.Intersect(list1).ToList();  
}  
if (TextBox4.Text != "")  
{  
    List<car> list1 = con.car.Where(r => r.powers == Convert.ToInt32(TextBox4.Text)).ToList();  
    list = list.Intersect(list1).ToList();  
}  
Repeater1.DataSource = list;  
Repeater1.DataBind();

到了这里，关于C# LINQ和Lambda表达式对照的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • c#中lambda表达式缩写推演

    c#中lambda表达式缩写推演

     

    2024年02月12日
    浏览(36)

  • C# 匿名方法和Lambda表达式

    1.匿名方法的演变 匿名方法是为了简化委托的实现，方便调用委托方法而出现的，同时，匿名方法也是学好lambda表达式的基础。在委托调用的方法中，如果方法只被调用一次，这个时候我们就没有必要创建具名方法，从而用匿名方法更为方便。 下面一段代码是声明并使用了一

    2024年02月15日
    浏览(45)

  • C#中的Lambda表达式应用方式及场景

    Lambda表达式在C#中提供了一种更简洁、灵活的方式来定义匿名函数，并在多种场景下提供了更好的代码编写体验。通过使用Lambda表达式，您可以减少冗余代码，并以更直观和简洁的方式表达函数的逻辑。 当使用C#中的Lambda表达式时，有多种应用方式和应用场景。 下面我将详细

    2024年02月12日
    浏览(47)
  • 【C# Programming】委托和lambda表达式、事件

    【C# Programming】委托和lambda表达式、事件

    目录 一、委托和lambda表达式 1.1 委托概述 1.2 委托类型的声明 1.3 委托的实例化 1.4 委托的内部机制  1.5 Lambda 表达式 1.6 语句lambda 1.7 表达式lambda 1.8 Lambda表达式 1.9 通用的委托 1.10 委托没有结构相等性 1.11 Lambda表达式和匿名方法的内部机制 1.12 外部变量 1.13 外部变量的

    2024年02月06日
    浏览(46)

  • C#学习相关系列之匿名方法和Lambda表达式

            匿名方法 顾名思义就是这类方法的特点是不需要特别去定义函数的名字的。一般我们需要一个函数，但又不想花时间去命名它的时候，就可以使用匿名方法。在 C# 中， 匿名方法通常表现为使用 delegate 运算符和 Lambda 表达式。（ Lambda 表达式 的本质也是 匿名方法

    2024年02月07日
    浏览(54)

  • 【C#进阶】C#中的委托、事件、回调函数、匿名函数和lambda表达式

    委托是一种类型，它可以存储对一个或多个方法的引用。它类似于C/C++中的函数指针，允许您将方法作为参数传递、存储和调用。 写法： delegate return_type delegate_name( ); return_type ：表示委托所引用方法的返回类型。 delegate_name ：表示委托的名称。 parameters ：表示委托所引用方法

    2024年02月06日
    浏览(58)
  • c# 从零到精通 数据库 定义LINQ查询表达式，从数组中查找长度小于7的所有项

    c# 从零到精通 数据库 定义LINQ查询表达式，从数组中查找长度小于7的所有项

    c# 从零到精通 数据库 定义LINQ查询表达式，从数组中查找长度小于7的所有项 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace LINQQuery { class Program { static void Main(string[] args) { //定义一个字符串数组 string[] strName = new string[] { “明日科技”,“C#编程词典”

    2024年02月10日
    浏览(48)
  • 如何使用C#中的Lambda表达式操作Redis Hash结构，简化缓存中对象属性的读写操作

    如何使用C#中的Lambda表达式操作Redis Hash结构，简化缓存中对象属性的读写操作

    Redis是一个开源的、高性能的、基于内存的键值数据库，它支持多种数据结构，如字符串、列表、集合、散列、有序集合等。其中，Redis的散列（Hash）结构是一个常用的结构，今天跟大家分享一个我的日常操作，如何使用Redis的散列（Hash）结构来缓存和查询对象的属性值，以

    2024年02月16日
    浏览(59)
  • 【javaSE】 Lambda表达式与Lambda表达式的使用

    【javaSE】 Lambda表达式与Lambda表达式的使用

    Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression） ，基于数学中的λ演算得名，也

    2024年02月08日
    浏览(62)

  • 以对象的方式访问html中的标签，比正则表达式更好用的方式获取html中的内容，linq方式直接获取所有的链接，更加先进的c#版本爬虫开源库

    这是我本人自己写的一个开源库，现已经发布到nuget，可以直接在vs的nuget包管理中搜索到，或者可以到nuget官网下载：https://www.nuget.org/packages/ZmjConvert/，也可以到我的个人网站上下载源码：https://www.zhaimaojun.cn/P/C%23%e6%a0%87%e7%ad%be%e7%b1%bb%e6%96%87%e6%9c%ac%e5%ba%8f%e5%88%97%e5%8c%96%e5%ba%9

    2024年03月15日
    浏览(55)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包