百度搜索：C# linq查询新对象

直接从list中查出一个新对象集合。

文章：https://blog.csdn.net/lym940928/article/details/80278783

from 临时变量 in 实现IEnumerable接口的对象
where条件表达式
[orderby 条件]
[group by 条件]
select 临时变量中被查询的值

示例代码，表达式写法：

//masterList是包含多个Master对象的一个列表
var res = from m in masterList
where m.Level > 8
select m.Name;
//此时res是一个包含符合条件的Name列表

example：（采用Lambda表达式的写法）

var res = masterList.Where(m=>m.Level>8)
//结果完全相同

多个限制条件

example：（表达式写法）

//masterList是包含多个Master对象的一个列表
var res = from m in masterList
where m.Level > 8 && m.Age > 50 //通过&&添加并列的条件
select m.Name;

example：（采用Lambda表达式的写法）

var res = masterList.Where(m=>m.Level > 8 && m.Age > 50);

自己写的示例代码，托条件或：

List list = new List(){ "a1","b","a1","d","e"};
var list2 = from a in list
where a == "a1" || a == "b"
select a;
foreach(var a in list2)
{
Console.WriteLine(a);
}

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

文章：30分钟LINQ教程

原文写的非常好，非常系统。阅读建议，如果懂了linq的前提，前面就不要看了，直接往后滚动页面看，因为文章太长了。

来看一篇伪代码：

from [type] id in source
[join [type] id in source on expr equals expr [into subGroup]]
[from [type] id in source | let id = expr | where condition]
[orderby ordering,ordering,ordering…]
select expr | group expr by key
[into id query]

<1>第一行的解释：

　　　　　　　　type是可选的，

　　　　　　　　id是集合中的一项，

　　　　　　　　source是一个集合，

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

<2>第二行的解释：　　　　　　　　

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

　　　　　　　　这里的source可以是一个全新的集合，可以不等于第一句中的source

　　　　　　　　expr可以是一个表达式

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

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

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

　　　　　　　　比如：

from c in db.Customers
join o in db.Orders on c.CustomerID
equals o.CustomerID into orders
select new
{
c.ContactName,
OrderCount = orders.Count()
};

<3>第三行的解释：　　　　　

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

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

　　　　　　　　比如：　　　　　　　　

    　　　　from u in users  
     　　　　let number = Int32.Parse(u.Username.Substring(u.Username.Length - 1))  
     　　　　where u.ID < 9 && number % 2 == 0  
     　　　　select u

　　　　　　　　一个查询表达式中可以有0个或多个where子句，where子句可以指定查询条件

<4>第四行的解释：

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

　　　　　　　　每个排序方式以逗号分割

<5>第五行的解释：

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

　　　　　　　　select后跟要检索的内容

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

　　　　　　　　比如：　　　　　　　　

from p in db.Products
group p by p.CategoryID into g
select new { g.Key, NumProducts = g.Count()};

<6>第六行的解释：

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

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

　　　　　　　　比如：

from p in db.Employees
select new
{
LastName = p.LastName,
TitleOfCourtesy = p.TitleOfCourtesy
} into EmployeesList
orderby EmployeesList.TitleOfCourtesy ascending
select EmployeesList;

三：参考资料

　　《LINQ实战》

　　《深入理解C#》第二版

　　《CLR VIA C#》第三版

　　《C# 高级编程》第四版

等等。