Linq入门
发布日期:2021-06-30 17:22:57 浏览次数:2 分类:技术文章

本文共 2671 字,大约阅读时间需要 8 分钟。

看起来,Linq是.NET独创的,java里面,或者其他开发语言里面,似乎没有这个东西。微软独创的东西,命运都不大好说,也许不久也会被微软自己抛弃。

但是目前来讲,年轻的.NET程序员写出来的代码,到处都是Linq,Lambda表达式。看着这些代码,我有一种生疏感,敬畏之心油然而生,难道自己真的是老了吗?

原因是自己对Linq不熟。

但其实,读了网上一篇文章以后,感觉比较好理解了:

读这篇文章,最大的感悟是,Linq 与 接口IEnumerable有很大关系:

IEnumerable接口是LINQ特性的核心接口

只有实现了IEnumerable接口的集合
才能执行相关的LINQ操作,比如select,where等

也就是说,可linq操作是支持遍历的。linq操作,本质上,就是个遍历操作。

以前对一个集合或者数组,我们要从中找出一些元素,就要用循环,for、while、或者foreach。那现在有了linq以后,可以写得更简洁一点。仅此而已。但是,现在的程序员,因为分工愈来愈精细,对数据库操作不甚了解,sql估计懒得写,就全部ORM,linq起来。

老实说,LINQ 跟 SQL 真的比较像,最显著的区别,只是select部分从开头移到了尾部而已。

from v in arr where v > 3 select v

以下虚线里的内容为抄自上面那篇参考文章:

======================================================================

先看一段伪代码:      

[csharp] 
  1. from [type] id in source  
  2. [join [type] id in source on expr equals expr [into subGroup]]  
  3. [from [type] id in source | let id = expr | where condition]  
  4. [orderby ordering,ordering,ordering...]  
  5. select expr | group expr by key  
  6. [into id query]  

<1>第一行的解释:

type是可选的,

id是集合中的一项,

source是一个集合,

如果集合中的类型与type指定的类型不同则导致强制转化

<2>第二行的解释:

一个查询表达式中可以有0个或多个join子句,

这里的source可以不等于第一句中的source

expr可以是一个表达式

[into subGroup] subGroup是一个中间变量,

它继承自IGrouping,代表一个分组,也就是说“一对多”里的“多”

可以通过这个变量得到这一组包含的对象个数,以及这一组对象的键

比如:

[csharp] 
  1. from c in db.Customers  
  2.             join o in db.Orders on c.CustomerID  
  3.             equals o.CustomerID into orders  
  4.             select new  
  5.             {  
  6.                 c.ContactName,  
  7.                 OrderCount = orders.Count()  
  8.             };  
<3>第三行的解释:     

一个查询表达式中可以有1个或多个from子句

一个查询表达式中可以有0个或多个let子句,let子句可以创建一个临时变量

比如:

[csharp] 
  1. from u in users  
  2.  let number = Int32.Parse(u.Username.Substring(u.Username.Length - 1))  
  3.  where u.ID < 9 && number % 2 == 0  
  4.  select u  
一个查询表达式中可以有0个或多个where子句,where子句可以指定查询条件

<4>第四行的解释:

一个查询表达式可以有0个或多个排序方式

每个排序方式以逗号分割

<5>第五行的解释:

一个查询表达式必须以select或者group by结束

select后跟要检索的内容

group by 是对检索的内容进行分组

比如:

[csharp] 
  1. from p in db.Products    
  2. group p by p.CategoryID into g    
  3. select new {  g.Key, NumProducts = g.Count()};   
<6>第六行的解释:

最后一个into子句起到的作用是

将前面语句的结果作为后面语句操作的数据源

比如:

[csharp] 
  1. from p in db.Employees  
  2.  select new  
  3.  {  
  4.      LastName = p.LastName,  
  5.      TitleOfCourtesy = p.TitleOfCourtesy  
  6.  } into EmployeesList  
  7.  orderby EmployeesList.TitleOfCourtesy ascending  
  8.  select EmployeesList;  
=====================================================================

请观看一些代码:

示例1:

[csharp] 
  1. var query = (from a in _DbContext.Set<Meta_View>()//_DbContext.Set<Meta_View>()是一个List对象,别管它  
  2.                     where a.ProjectID == projectId && a.Creator == account  
  3.                     select (new ViewTag  
  4.                     {  
  5.                         ViewId = a.ID  
  6.                         ,Name = a.Name  
  7.                         ,IsValid = a.IsValid  
  8.                         ,Seq = a.Seq  
  9.                         ,ChangeType = (byte)ViewTag.EChangeType.NoChanged  
  10.                     }));  
  11.             return query.ToList<ViewTag>();  

示例2

[csharp] 
  1. IEnumerable<Meta_View> dbViews = _DbContext.Set<Meta_View>()  
  2.     .Where(m => m.ProjectID.Equals(projectId) && m.Creator.Equals(account));  

转载地址:https://leftfist.blog.csdn.net/article/details/42437661 如侵犯您的版权,请留言回复原文章的地址,我们会给您删除此文章,给您带来不便请您谅解!

上一篇:javascript下获取guid或者UTC时间作为唯一值
下一篇:C#下JSON字符串的反序列化

发表评论

最新留言

感谢大佬
[***.8.128.20]2024年04月26日 16时53分04秒