[{"data":1,"prerenderedAt":2082},["ShallowReactive",2],{"page-\u002Fcsharp\u002Flinq":3},{"id":4,"title":5,"body":6,"description":2075,"extension":2076,"meta":2077,"navigation":262,"path":2078,"seo":2079,"stem":2080,"__hash__":2081},"content\u002Fcsharp\u002Flinq.md","Linq",{"type":7,"value":8,"toc":2038},"minimark",[9,21,24,27,30,35,43,57,60,78,99,102,217,220,223,305,308,313,320,325,338,351,358,387,392,399,409,451,454,507,514,519,557,560,566,650,671,674,703,708,743,750,753,757,766,769,774,777,782,785,789,802,805,808,813,816,822,825,852,855,858,861,867,870,939,942,948,951,954,957,960,989,993,996,1003,1006,1009,1059,1062,1068,1074,1083,1117,1138,1141,1164,1169,1172,1175,1201,1205,1208,1211,1214,1220,1223,1229,1232,1235,1241,1244,1250,1253,1255,1260,1270,1278,1281,1284,1290,1296,1299,1302,1308,1311,1317,1321,1324,1327,1333,1337,1340,1343,1349,1352,1358,1362,1365,1368,1374,1377,1383,1386,1396,1402,1447,1451,1462,1465,1469,1472,1477,1480,1483,1616,1620,1623,1677,1681,1695,1698,1775,1779,1786,1790,1793,1796,1799,1802,1805,1814,1818,1821,1824,1859,1862,1865,1871,1899,1901,1912,1972,1978,1986,1989,2034],[10,11,12,13,17,18],"p",{},"语言集成查询（LINQ）是.Net 3.5和Visual Studio 2008引入的功能强大的查询语言。",[14,15,16],"strong",{},"LINQ可与C＃或Visual Basic一起使用","，",[14,19,20],{},"以查询不同的数据源。",[10,22,23],{},"LINQ（语言集成查询）是C＃和VB.NET中的统一查询语法，用于从不同的源和格式检索数据。它集成在C＃或VB中，从而消除了编程语言和数据库之间的不匹配，并为不同类型的数据源提供了单个查询接口。",[10,25,26],{},"例如，SQL是一种结构化查询语言，用于保存和检索数据库中的数据。同样，LINQ是C＃和VB.NET中内置的结构化查询语法，用于从不同类型的数据源（例如集合，ADO.Net DataSet，XML Docs，Web服务和MS SQL Server和其他数据库）中检索数据。",[10,28,29],{},"LINQ查询将结果作为对象返回。它使您可以在结果集上使用面向对象的方法，而不必担心将不同格式的结果转换为对象。",[31,32,34],"h2",{"id":33},"什么是委托类型","什么是委托类型：",[36,37,39,40],"h3",{"id":38},"_1-委托delegate","1. ",[14,41,42],{},"委托（Delegate）",[10,44,45,48,49,52,53,56],{},[14,46,47],{},"委托是 C# 中一种类型安全的函数指针","，允许你",[14,50,51],{},"将方法作为参数传递","、",[14,54,55],{},"存储和调用","。委托定义了方法的签名（返回类型和参数类型），并可以绑定到任何匹配此签名的方法。",[10,58,59],{},"例如：",[61,62,67],"pre",{"className":63,"code":64,"language":65,"meta":66,"style":66},"language-c# shiki shiki-themes github-light github-dark","public delegate int MyDelegate(int x, int y);\n\n","c#","",[68,69,70],"code",{"__ignoreMap":66},[71,72,75],"span",{"class":73,"line":74},"line",1,[71,76,77],{},"public delegate int MyDelegate(int x, int y);\n",[10,79,80,81,84,85,88,89],{},"这个 ",[68,82,83],{},"MyDelegate"," ",[14,86,87],{},"委托","可以",[14,90,91,92,95,96,98],{},"指向任何接受两个 ",[68,93,94],{},"int"," 参数并返回一个 ",[68,97,94],{}," 的方法。",[36,100,101],{"id":101},"委托类型的基本形式",[103,104,105,132,171,201],"ol",{},[106,107,108,111,112],"li",{},[14,109,110],{},"无参数的委托",":",[113,114,115],"ul",{},[106,116,117,120,123,124],{},[68,118,119],{},"Action",[121,122],"br",{},": 用于没有返回值的方法。",[61,125,130],{"className":126,"code":128,"language":129},[127],"language-text","\nAction myAction = () => Console.WriteLine(\"Hello, World!\");\n","text",[68,131,128],{"__ignoreMap":66},[106,133,134,111,137],{},[14,135,136],{},"有返回值的委托",[113,138,139],{},[106,140,141,144,146,147,153,155,156,162,164,165],{},[68,142,143],{},"Func\u003CT, TResult>",[121,145],{},": 用于有返回值的方法，",[61,148,151],{"className":149,"code":150,"language":129},[127],"T\n",[68,152,150],{"__ignoreMap":66},[121,154],{},"是输入参数类型，",[61,157,160],{"className":158,"code":159,"language":129},[127],"TResult\n",[68,161,159],{"__ignoreMap":66},[121,163],{},"是返回值类型。",[61,166,169],{"className":167,"code":168,"language":129},[127],"\nFunc\u003Cint, int, int> add = (x, y) => x + y;\n",[68,170,168],{"__ignoreMap":66},[106,172,173,111,176],{},[14,174,175],{},"有条件返回值的委托",[113,177,178],{},[106,179,180,183,185,186,192,194,195],{},[68,181,182],{},"Predicate\u003CT>",[121,184],{},": 用于条件测试，返回",[61,187,190],{"className":188,"code":189,"language":129},[127],"bool\n",[68,191,189],{"__ignoreMap":66},[121,193],{},"。",[61,196,199],{"className":197,"code":198,"language":129},[127],"\nPredicate\u003Cint> isEven = number => number % 2 == 0;\n",[68,200,198],{"__ignoreMap":66},[106,202,203,111,206],{},[14,204,205],{},"自定义委托类型",[113,207,208],{},[106,209,210,211],{},"可以定义自己的委托类型，以适应特定的需求。",[61,212,215],{"className":213,"code":214,"language":129},[127],"public delegate bool MyPredicate(int number);\n\nMyPredicate isGreaterThanTen = number => number > 10;\n",[68,216,214],{"__ignoreMap":66},[36,218,219],{"id":219},"委托类型与函数参数类型的关系",[10,221,222],{},"委托类型的作用是定义方法的参数和返回类型。这使得你可以将方法作为参数传递，或者用委托类型来调用方法。它们是方法签名的类型安全表示，确保了方法调用的一致性。",[61,224,226],{"className":63,"code":225,"language":65,"meta":66,"style":66},"public static void Main()\n{\n    \u002F\u002F 使用委托类型定义方法\n    MathOperation add = (x, y) => x + y;\n    MathOperation multiply = (x, y) => x * y;\n\n    \u002F\u002F 使用委托调用方法\n    int sum = add(5, 3);         \u002F\u002F sum = 8\n    int product = multiply(5, 3); \u002F\u002F product = 15\n\n    Console.WriteLine($\"Sum: {sum}\");\n    Console.WriteLine($\"Product: {product}\");\n}\n",[68,227,228,233,239,245,251,257,264,270,276,282,287,293,299],{"__ignoreMap":66},[71,229,230],{"class":73,"line":74},[71,231,232],{},"public static void Main()\n",[71,234,236],{"class":73,"line":235},2,[71,237,238],{},"{\n",[71,240,242],{"class":73,"line":241},3,[71,243,244],{},"    \u002F\u002F 使用委托类型定义方法\n",[71,246,248],{"class":73,"line":247},4,[71,249,250],{},"    MathOperation add = (x, y) => x + y;\n",[71,252,254],{"class":73,"line":253},5,[71,255,256],{},"    MathOperation multiply = (x, y) => x * y;\n",[71,258,260],{"class":73,"line":259},6,[71,261,263],{"emptyLinePlaceholder":262},true,"\n",[71,265,267],{"class":73,"line":266},7,[71,268,269],{},"    \u002F\u002F 使用委托调用方法\n",[71,271,273],{"class":73,"line":272},8,[71,274,275],{},"    int sum = add(5, 3);         \u002F\u002F sum = 8\n",[71,277,279],{"class":73,"line":278},9,[71,280,281],{},"    int product = multiply(5, 3); \u002F\u002F product = 15\n",[71,283,285],{"class":73,"line":284},10,[71,286,263],{"emptyLinePlaceholder":262},[71,288,290],{"class":73,"line":289},11,[71,291,292],{},"    Console.WriteLine($\"Sum: {sum}\");\n",[71,294,296],{"class":73,"line":295},12,[71,297,298],{},"    Console.WriteLine($\"Product: {product}\");\n",[71,300,302],{"class":73,"line":301},13,[71,303,304],{},"}\n",[10,306,307],{},"}",[10,309,310,111],{},[14,311,312],{},"示例",[36,314,316,317],{"id":315},"_2-lambda-表达式","2. ",[14,318,319],{},"Lambda 表达式",[10,321,322],{},[14,323,324],{},"Func\u003Cint, int, int> add = (x, y) => x + y;",[10,326,327,328,194,331,17,334,337],{},"Lambda 表达式是一个简化的语法，",[14,329,330],{},"用于创建匿名方法或委托",[14,332,333],{},"它允许你以更简洁的方式定义方法",[14,335,336],{},"而无需显式声明一个方法或委托类型","。Lambda 表达式常用于 LINQ 查询、事件处理和其他需要委托的场景。",[10,339,340,341,344,345,194],{},"这里的 ",[68,342,343],{},"(x, y) => x + y"," 是一个 Lambda 表达式，它表示",[14,346,347,348,350],{},"一个接受两个 ",[68,349,94],{}," 参数并返回它们和的匿名方法",[36,352,354,357],{"id":353},"funct1-t2-tresult-解释",[68,355,356],{},"Func\u003CT1, T2, TResult>"," 解释",[113,359,360,378],{},[106,361,362,366,367,370,371,374,375,98],{},[14,363,364],{},[68,365,356],{}," 是一个预定义的泛型委托类型，它表示一个接受两个参数 ",[68,368,369],{},"T1"," 和 ",[68,372,373],{},"T2","，并返回一个结果 ",[68,376,377],{},"TResult",[106,379,380,383,384,194],{},[68,381,382],{},"Func"," 是 .NET 中提供的一组委托类型之一，它用于",[14,385,386],{},"定义接受参数并返回值的委托",[10,388,389],{},[14,390,391],{},"（x，y）是输入参数，x+y是返回的参数",[36,393,395,396],{"id":394},"_3-委托类型与-lambda-表达式","3. ",[14,397,398],{},"委托类型与 Lambda 表达式",[10,400,401,402,404,405,408],{},"Lambda 表达式实际上与委托类型相关联。",[14,403,319],{},"会",[14,406,407],{},"根据其参数列表和返回类型自动推导出一个委托类型","。常用的委托类型包括：",[113,410,411,426,440],{},[106,412,413,418,419,422,423,194],{},[14,414,415],{},[68,416,417],{},"Action\u003CT>",": 表示一个",[14,420,421],{},"不返回结果的委托","，通常用",[14,424,425],{},"于无返回值的方法",[106,427,428,432,433,436,437,439],{},[14,429,430],{},[68,431,143],{},": 表示一个有返回结果的委托，",[68,434,435],{},"T"," 是输入参数的类型，",[68,438,377],{}," 是返回结果的类型。",[106,441,442,446,447,450],{},[14,443,444],{},[68,445,182],{},": 表示一个带有返回值为 ",[68,448,449],{},"bool"," 的委托，通常用于条件测试。",[36,452,453],{"id":453},"参数和返回值",[113,455,456,474,490],{},[106,457,458,463,464,466,467,470,471,473],{},[14,459,460,461],{},"第一个 ",[68,462,94],{},": 这是 ",[68,465,382],{}," 委托的第一个参数类型。在此例中，",[68,468,469],{},"x"," 是第一个 ",[68,472,94],{}," 类型的参数。",[106,475,476,463,481,483,484,487,488,473],{},[14,477,478,479],{},"第二个 ",[68,480,94],{},[68,482,382],{}," 委托的第二个参数类型。在此例中，",[68,485,486],{},"y"," 是第二个 ",[68,489,94],{},[106,491,492,463,497,499,500,503,504,506],{},[14,493,494,495],{},"第三个 ",[68,496,94],{},[68,498,382],{}," 委托的返回值类型。在此例中，",[68,501,502],{},"x + y"," 的结果是一个 ",[68,505,94],{}," 类型的值，作为这个委托的返回结果。",[36,508,510,511,513],{"id":509},"更多-func-类型","更多 ",[68,512,382],{}," 类型",[10,515,516,518],{},[68,517,382],{}," 委托可以接受多达 16 个参数，具体取决于泛型参数的数量。例如：",[113,520,521,531,544],{},[106,522,523,528,529,98],{},[14,524,525],{},[68,526,527],{},"Func\u003Cint>",": 表示一个没有参数且返回一个 ",[68,530,94],{},[106,532,533,538,539,95,542,98],{},[14,534,535],{},[68,536,537],{},"Func\u003Cstring, bool>",": 表示一个接受一个 ",[68,540,541],{},"string",[68,543,449],{},[106,545,546,551,552,95,555,98],{},[14,547,548],{},[68,549,550],{},"Func\u003Cdouble, double, double, double>",": 表示一个接受三个 ",[68,553,554],{},"double",[68,556,554],{},[36,558,559],{"id":559},"示例代码",[10,561,562,563,565],{},"以下是一个完整的示例，展示了如何使用 ",[68,564,382],{}," 委托类型：",[61,567,569],{"className":63,"code":568,"language":65,"meta":66,"style":66},"using System;\n\npublic class Program\n{\n    public static void Main()\n    {\n        \u002F\u002F 定义一个 Func 委托，接受两个 int 参数并返回它们的和\n        Func\u003Cint, int, int> add = (x, y) => x + y;\n        \n        \u002F\u002F 调用 Func 委托\n        int result = add(3, 4); \u002F\u002F result = 7\n        \n        \u002F\u002F 输出结果\n        Console.WriteLine(result);\n    }\n}\n\n",[68,570,571,576,580,585,589,594,599,604,609,614,619,624,628,633,639,645],{"__ignoreMap":66},[71,572,573],{"class":73,"line":74},[71,574,575],{},"using System;\n",[71,577,578],{"class":73,"line":235},[71,579,263],{"emptyLinePlaceholder":262},[71,581,582],{"class":73,"line":241},[71,583,584],{},"public class Program\n",[71,586,587],{"class":73,"line":247},[71,588,238],{},[71,590,591],{"class":73,"line":253},[71,592,593],{},"    public static void Main()\n",[71,595,596],{"class":73,"line":259},[71,597,598],{},"    {\n",[71,600,601],{"class":73,"line":266},[71,602,603],{},"        \u002F\u002F 定义一个 Func 委托，接受两个 int 参数并返回它们的和\n",[71,605,606],{"class":73,"line":272},[71,607,608],{},"        Func\u003Cint, int, int> add = (x, y) => x + y;\n",[71,610,611],{"class":73,"line":278},[71,612,613],{},"        \n",[71,615,616],{"class":73,"line":284},[71,617,618],{},"        \u002F\u002F 调用 Func 委托\n",[71,620,621],{"class":73,"line":289},[71,622,623],{},"        int result = add(3, 4); \u002F\u002F result = 7\n",[71,625,626],{"class":73,"line":295},[71,627,613],{},[71,629,630],{"class":73,"line":301},[71,631,632],{},"        \u002F\u002F 输出结果\n",[71,634,636],{"class":73,"line":635},14,[71,637,638],{},"        Console.WriteLine(result);\n",[71,640,642],{"class":73,"line":641},15,[71,643,644],{},"    }\n",[71,646,648],{"class":73,"line":647},16,[71,649,304],{},[10,651,652,653,656,657,660,661,663,664,667,668,194],{},"在这个例子中，",[68,654,655],{},"add"," 是一个 ",[68,658,659],{},"Func\u003Cint, int, int>"," 类型的委托，它接受两个 ",[68,662,94],{}," 参数并返回它们的和。调用 ",[68,665,666],{},"add(3, 4)"," 会返回 ",[68,669,670],{},"7",[36,672,673],{"id":673},"总结",[10,675,676,678,679,681,682,684,685,687,688,690,691,694,695,194,698,370,700,702],{},[68,677,659],{}," 是一个泛型委托类型，表示一个接受两个 ",[68,680,94],{}," 类型参数并返回一个 ",[68,683,94],{}," 类型结果的方法。Lambda 表达式 ",[68,686,343],{}," 匹配这个委托类型，因为它接受两个 ",[68,689,94],{}," 参数并返回它们的和。",[14,692,693],{},"Lambda 表达式是一个语法糖，用于创建匿名方法或委托","，它可以",[14,696,697],{},"与多种不同类型的委托配合使用",[68,699,382],{},[68,701,119],{}," 是最常用的两种委托类型，但实际上你可以使用 Lambda 表达式来创建任何符合特定签名的委托类型。",[704,705,707],"h1",{"id":706},"linq-apinet","LINQ API（.Net）",[10,709,710,711,714,715,718,719,723,724,733,734,739,740,742],{},"我们可以为实现",[68,712,713],{},"IEnumerable \u003CT>","或 ",[68,716,717],{},"IQueryable \u003CT>","接口的类编写LINQ查询。",[720,721,722],"em",{},"System.Linq的","命名空间包括下列类和接口要求对LINQ查询。当你实现 ",[14,725,726,729,730],{},[68,727,728],{},"IEnumerable\u003CT>"," 或 ",[68,731,732],{},"IQueryable\u003CT>"," 接口的类时，你可以",[14,735,736,737],{},"编写 LINQ 查询来操作数据。",[68,738,728],{}," 提供了对内存中的数据进行查询的能力，而 ",[68,741,732],{}," 允许你在查询时将表达式树转化为数据库查询",[10,744,745,749],{},[746,747],"img",{"alt":746,"src":748},"https:\u002F\u002Fwww.cainiaojc.com\u002Fstatic\u002Fupload\u002F201229\u002F1137310.png","LINQ API在Visual Studio中添加新类时，默认包含 System.Linq 命名空间。。",[10,751,752],{},"LINQ查询对实现IEnumerable或IQueryable接口的类使用扩展方法。Enumerable和Queryable是两个静态类，它们包含编写LINQ查询的扩展方法。",[31,754,756],{"id":755},"可枚举类enumerable","可枚举类(Enumerable)",[10,758,759,760,762,763,765],{},"Enumerable类包括用于实现",[68,761,728],{},"接口的类的扩展方法，例如，所有内置集合类都实现了",[68,764,728],{},"接口，因此我们可以编写LINQ查询来从内置集合中检索数据。",[10,767,768],{},"下图显示了Enumerable类中包含的扩展方法，可以与C＃或VB.Net中的泛型集合一起使用。",[10,770,771],{},[746,772],{"alt":746,"src":773},"https:\u002F\u002Fwww.cainiaojc.com\u002Fstatic\u002Fupload\u002F201229\u002F1137311.png",[10,775,776],{},"下图显示了Enumerable该类中所有可用的扩展方法。",[10,778,779],{},[746,780],{"alt":746,"src":781},"https:\u002F\u002Fwww.cainiaojc.com\u002Fstatic\u002Fupload\u002F201229\u002F1137312.png",[10,783,784],{},"Enumerable 类",[31,786,788],{"id":787},"可查询queryable","可查询(Queryable)",[10,790,791,792,795,796,798,799,801],{},"Queryable类包含用于实现成员“> ",[68,793,794],{},"IQueryable \u003Ct>","接口的类的扩展方法。该",[68,797,732],{},"接口用于提供针对已知数据类型的特定数据源的查询功能，例如，Entity Framework api实现了",[68,800,732],{},"针对通过底层数据库（例如MS SQL Server）支持LINQ查询。",[10,803,804],{},"此外，还有一些API可用于访问第三方数据。例如，LINQ to Amazon提供了将LINQ与Amazon Web服务结合使用以搜索书籍和其他物品的功能。这可以通过IQueryable为Amazon实现接口来实现。",[10,806,807],{},"下图显示了Queryable该类中可用的扩展方法，可以与各种本机或第三方数据提供程序一起使用。",[10,809,810],{},[746,811],{"alt":746,"src":812},"https:\u002F\u002Fwww.cainiaojc.com\u002Fstatic\u002Fupload\u002F201229\u002F1137313.png",[10,814,815],{},"下图显示了Queryable该类中可用的扩展方法。",[10,817,818,821],{},[746,819],{"alt":746,"src":820},"https:\u002F\u002Fwww.cainiaojc.com\u002Fstatic\u002Fupload\u002F201229\u002F1137314.png","Queryable 类",[31,823,824],{"id":824},"要记住的要点",[103,826,827,830,833,839,844,849],{},[106,828,829],{},"使用 System.LINQ 命名空间来使用 LINQ。",[106,831,832],{},"LINQ api包括两个主要的静态类Enumerable 和 Queryable。",[106,834,835,836,838],{},"静态Enumerable类包括用于实现",[68,837,713],{},"接口的类的扩展方法。",[106,840,841,843],{},[68,842,713],{},"集合的类型是内存中的集合，例如List，Dictionary，SortedList，Queue，HashSet，LinkedList。",[106,845,846,847,838],{},"静态Queryable类包括用于实现",[68,848,717],{},[106,850,851],{},"远程查询提供程序实现了例如Linq-to-SQL，LINQ-to-Amazon等。",[31,853,854],{"id":854},"查询语法",[10,856,857],{},"查询语法类似于数据库的SQL（结构化查询语言）。它在C＃或VB代码中定义。",[10,859,860],{},"LINQ查询语法：",[61,862,865],{"className":863,"code":864,"language":129},[127],"from \u003Crange variable> in \u003CIEnumerable\u003CT> or IQueryable\u003CT> Collection>\n\n\u003CStandard Query Operators> \u003Clambda expression>\n\n\u003Cselect or groupBy operator> \u003Cresult formation>\n",[68,866,864],{"__ignoreMap":66},[10,868,869],{},"LINQ查询语法以from关键字开头，以select关键字结尾。下面是一个示例LINQ查询，该查询返回一个字符串集合，其中包含一个单词“ Tutorials”。",[61,871,873],{"className":63,"code":872,"language":65,"meta":66,"style":66},"\u002F\u002F 字符串集合\nIList\u003Cstring> stringList = new List\u003Cstring>() { \n    \"C# Tutorials\",\n    \"VB.NET Tutorials\",\n    \"Learn C++\",\n    \"MVC Tutorials\" ,\n    \"Java\" \n};\n\n\u002F\u002F LINQ查询语法\nvar result = from s in stringList\n            where s.Contains(\"Tutorials\") \n            select s;\n",[68,874,875,880,885,890,895,900,905,910,915,919,924,929,934],{"__ignoreMap":66},[71,876,877],{"class":73,"line":74},[71,878,879],{},"\u002F\u002F 字符串集合\n",[71,881,882],{"class":73,"line":235},[71,883,884],{},"IList\u003Cstring> stringList = new List\u003Cstring>() { \n",[71,886,887],{"class":73,"line":241},[71,888,889],{},"    \"C# Tutorials\",\n",[71,891,892],{"class":73,"line":247},[71,893,894],{},"    \"VB.NET Tutorials\",\n",[71,896,897],{"class":73,"line":253},[71,898,899],{},"    \"Learn C++\",\n",[71,901,902],{"class":73,"line":259},[71,903,904],{},"    \"MVC Tutorials\" ,\n",[71,906,907],{"class":73,"line":266},[71,908,909],{},"    \"Java\" \n",[71,911,912],{"class":73,"line":272},[71,913,914],{},"};\n",[71,916,917],{"class":73,"line":278},[71,918,263],{"emptyLinePlaceholder":262},[71,920,921],{"class":73,"line":284},[71,922,923],{},"\u002F\u002F LINQ查询语法\n",[71,925,926],{"class":73,"line":289},[71,927,928],{},"var result = from s in stringList\n",[71,930,931],{"class":73,"line":295},[71,932,933],{},"            where s.Contains(\"Tutorials\") \n",[71,935,936],{"class":73,"line":301},[71,937,938],{},"            select s;\n",[10,940,941],{},"下图显示了LINQ查询语法的结构。",[10,943,944,947],{},[746,945],{"alt":746,"src":946},"https:\u002F\u002Fwww.cainiaojc.com\u002Fstatic\u002Fupload\u002F201229\u002F1138520.png","LINQ查询语法",[10,949,950],{},"查询语法以 From 子句开头，后跟 Range 变量。From 子句的结构类似于“ From rangeVariableName in i enumerablecollection”。在英语中，这意味着，从集合中的每个对象。它类似于 foreach 循环:foreach(Student s in studentList)。",[10,952,953],{},"在FROM子句之后，可以使用不同的标准查询运算符来过滤，分组和联接集合中的元素。LINQ中大约有50个标准查询运算符。在上图中，我们使用了“ where”运算符（又称子句），后跟一个条件。通常使用lambda表达式来表达此条件。",[10,955,956],{},"LINQ查询语法始终以Select或Group子句结尾。Select子句用于整形数据。您可以按原样选择整个对象，也可以仅选择某些属性。在上面的示例中，我们选择了每个结果字符串元素。",[31,958,824],{"id":959},"要记住的要点-1",[103,961,962,968,983,986],{},[106,963,964,965,967],{},"顾名思义，",[14,966,854],{},"与SQL（结构查询语言）语法相同。",[106,969,970,971,974,975,978,979,982],{},"查询语法以",[720,972,973],{},"from","子句开头，可以以",[720,976,977],{},"Select","或",[720,980,981],{},"GroupBy","子句结尾。",[106,984,985],{},"使用各种其他运算符，例如过滤，联接，分组，排序运算符来构造所需的结果。",[106,987,988],{},"隐式类型变量-var可用于保存LINQ查询的结果。",[704,990,992],{"id":991},"linq-方法语法","LINQ 方法语法",[10,994,995],{},"在上一节中，您已经了解了LINQ查询语法。在这里，您将了解方法语法。",[10,997,998,999,1002],{},"方法语法（也称为连贯语法）使用",[14,1000,1001],{},"Enumerable 或 Queryable静态类","中包含的扩展方法，类似于您调用任何类的扩展方法的方式。",[10,1004,1005],{},"编译器在编译时将查询语法转换为方法语法。",[10,1007,1008],{},"以下是LINQ方法语法查询示例，该查询返回字符串集合，其中包含单词“ Tutorials”。",[61,1010,1012],{"className":63,"code":1011,"language":65,"meta":66,"style":66},"\u002F\u002F 字符串集合\nIList\u003Cstring> stringList = new List\u003Cstring>() { \n    \"C# Tutorials\",\n    \"VB.NET Tutorials\",\n    \"Learn C++\",\n    \"MVC Tutorials\" ,\n    \"Java\" \n};\n\n\u002F\u002F LINQ查询语法\nvar result = stringList.Where(s => s.Contains(\"Tutorials\"));\n",[68,1013,1014,1018,1022,1026,1030,1034,1038,1042,1046,1050,1054],{"__ignoreMap":66},[71,1015,1016],{"class":73,"line":74},[71,1017,879],{},[71,1019,1020],{"class":73,"line":235},[71,1021,884],{},[71,1023,1024],{"class":73,"line":241},[71,1025,889],{},[71,1027,1028],{"class":73,"line":247},[71,1029,894],{},[71,1031,1032],{"class":73,"line":253},[71,1033,899],{},[71,1035,1036],{"class":73,"line":259},[71,1037,904],{},[71,1039,1040],{"class":73,"line":266},[71,1041,909],{},[71,1043,1044],{"class":73,"line":272},[71,1045,914],{},[71,1047,1048],{"class":73,"line":278},[71,1049,263],{"emptyLinePlaceholder":262},[71,1051,1052],{"class":73,"line":284},[71,1053,923],{},[71,1055,1056],{"class":73,"line":289},[71,1057,1058],{},"var result = stringList.Where(s => s.Contains(\"Tutorials\"));\n",[10,1060,1061],{},"下图说明了LINQ方法语法的结构。",[10,1063,1064,1067],{},[746,1065],{"alt":746,"src":1066},"https:\u002F\u002Fwww.cainiaojc.com\u002Fstatic\u002Fupload\u002F201229\u002F1339390.png","LINQ方法语法结构",[10,1069,1070,1071,194],{},"如上图所示，",[14,1072,1073],{},"方法语法包括扩展方法和 Lambda 表达式",[10,1075,1076,111],{},[14,1077,1078,1079,1082],{},"谓词 (",[68,1080,1081],{},"s => s.Contains(\"Tutorials\")",")",[113,1084,1085,1095],{},[106,1086,1087,1088,1091,1092,194],{},"这是一个 lambda 表达式，它定义了一个函数来检查每个字符串 ",[68,1089,1090],{},"s"," 是否包含 ",[68,1093,1094],{},"\"Tutorials\"",[106,1096,1097,1100,1101,1103,1104,1106,1107,1109,1110,1113,1114,194],{},[68,1098,1099],{},"s.Contains(\"Tutorials\")"," 是 ",[68,1102,541],{}," 类型的一个方法，用于检查字符串 ",[68,1105,1090],{}," 是否包含子字符串 ",[68,1108,1094],{},"。如果包含，则返回 ",[68,1111,1112],{},"true","；否则返回 ",[68,1115,1116],{},"false",[10,1118,1119,1124,1125,656,1127,1130,1131,1134,1135,1137],{},[14,1120,1121],{},[68,1122,1123],{},"result",": ",[68,1126,1123],{},[68,1128,1129],{},"IEnumerable\u003Cstring>"," 类型的集合，包含了所有 ",[68,1132,1133],{},"stringList"," 中包含 ",[68,1136,1094],{}," 的字符串。",[10,1139,1140],{},"在枚举(Enumerable)类中定义的扩展方法 Where ()。",[10,1142,1143,1144,1147,1148,1159,1160,1163],{},"如果",[14,1145,1146],{},"检查Where扩展方法的签名","，就会发现",[14,1149,1150,1151,1158],{},"Where方法接受一个 ",[1152,1153,1157],"a",{"href":1154,"rel":1155},"https:\u002F\u002Fwww.cainiaojc.com\u002Fcsharp\u002Fcsharp-predicate.html",[1156],"nofollow","predicate 委托"," Func\u003CStudent,bool>","。这意味着您可以传递任何接受Student对象作为",[14,1161,1162],{},"输入参数并返回布尔值的委托函数","，如下图所示。lambda表达式用作Where子句中传递的委托。在下一节学习 Lambda 表达式。",[10,1165,1166],{},[746,1167],{"alt":746,"src":1168},"https:\u002F\u002Fwww.cainiaojc.com\u002Fstatic\u002Fupload\u002F201229\u002F1339391.png",[10,1170,1171],{},"Where 中的 Func 委托",[31,1173,824],{"id":1174},"要记住的要点-2",[103,1176,1177,1186,1192],{},[106,1178,964,1179,1182,1183,194],{},[14,1180,1181],{},"方法语法","就像",[14,1184,1185],{},"调用扩展方法",[106,1187,1188,1189,1191],{},"LINQ",[14,1190,1181],{},"又称Fluent语法（连贯语法），因为它允许一系列扩展方法调用。",[106,1193,1194,1197,1198],{},[14,1195,1196],{},"隐式类型变量-var","可用于",[14,1199,1200],{},"保存LINQ查询的结果。",[704,1202,1204],{"id":1203},"linq-lambda-表达式","LINQ Lambda 表达式",[10,1206,1207],{},"C＃3.0（.NET 3.5）引入了lambda表达式以及 LINQ。lambda表达式是使用某些特殊语法表示匿名方法的一种较短方法。",[10,1209,1210],{},"例如，采用以下匿名方法检查学生是否为青少年：",[10,1212,1213],{},"示例：C＃中的匿名方法",[61,1215,1218],{"className":1216,"code":1217,"language":129},[127],"delegate(Student s) { return s.Age > 12 && s.Age \u003C 20; };\n",[68,1219,1217],{"__ignoreMap":66},[10,1221,1222],{},"示例：VB.Net中的匿名方法",[61,1224,1227],{"className":1225,"code":1226,"language":129},[127],"Dim isStudentTeenAger = Function(s As Student) As Boolean\n                                    Return s.Age > 12 And s.Age \u003C 20\n                        End Function\n",[68,1228,1226],{"__ignoreMap":66},[10,1230,1231],{},"可以使用C＃和VB.Net中的Lambda表达式来表示上述匿名方法，如下所示：",[10,1233,1234],{},"示例：C＃中的Lambda表达式",[61,1236,1239],{"className":1237,"code":1238,"language":129},[127],"s => s.Age > 12 && s.Age \u003C 20\n",[68,1240,1238],{"__ignoreMap":66},[10,1242,1243],{},"示例：VB.Net中的Lambda表达式",[61,1245,1248],{"className":1246,"code":1247,"language":129},[127],"Function(s) s.Age  > 12 And s.Age \u003C 20\n",[68,1249,1247],{"__ignoreMap":66},[10,1251,1252],{},"让我们看看lambda表达式是如何从以下匿名方法演变而来的。",[10,1254,1213],{},[61,1256,1258],{"className":1257,"code":1217,"language":129},[127],[68,1259,1217],{"__ignoreMap":66},[10,1261,1262,1263,1266,1267,194],{},"Lambda表达式是",[14,1264,1265],{},"通过首先删除委托关键字和参数类型","并",[14,1268,1269],{},"添加lambda运算符=>从匿名方法演变而来的",[10,1271,1272,1275],{},[746,1273],{"alt":746,"src":1274},"https:\u002F\u002Fwww.cainiaojc.com\u002Fstatic\u002Fupload\u002F201229\u002F1400160.png",[14,1276,1277],{},"来自匿名方法的Lambda表达式",[10,1279,1280],{},"上面的lambda表达式绝对有效，但是如果我们只有一个返回值的语句，则不需要花括号，return和分号。因此我们可以删除它。具有多个参数的Lambda表达式",[10,1282,1283],{},"如果您需要传递多个参数，则可以将参数括在括号中，如下所示：",[10,1285,1286,1287],{},"示例：",[14,1288,1289],{},"在Lambda表达式C＃中指定多个参数",[61,1291,1294],{"className":1292,"code":1293,"language":129},[127],"(s, youngAge) => s.Age >= youngage;\n",[68,1295,1293],{"__ignoreMap":66},[10,1297,1298],{},"如果觉得参数表达不清，您还可以给出每个参数的类型：",[10,1300,1301],{},"示例：指定参数类型",[61,1303,1306],{"className":1304,"code":1305,"language":129},[127],"(Student s,int youngAge) => s.Age >= youngage;\n",[68,1307,1305],{"__ignoreMap":66},[10,1309,1310],{},"示例：在Lambda表达式中指定多个参数VB.Net",[61,1312,1315],{"className":1313,"code":1314,"language":129},[127],"Function(s, youngAge) s.Age >= youngAge\n",[68,1316,1314],{"__ignoreMap":66},[31,1318,1320],{"id":1319},"不带参数的lambda表达式","不带参数的Lambda表达式",[10,1322,1323],{},"lambda表达式中不必至少有一个参数。lambda表达式也可以不带任何参数来指定。",[10,1325,1326],{},"示例：不带参数的Lambda表达式",[61,1328,1331],{"className":1329,"code":1330,"language":129},[127],"() => Console.WriteLine(\"无参数 lambda 表达式\")\n",[68,1332,1330],{"__ignoreMap":66},[31,1334,1336],{"id":1335},"lambda表达主体中的多个语句","Lambda表达主体中的多个语句",[10,1338,1339],{},"如果要在主体中包含多个语句，可以将表达式用大括号括起来：",[10,1341,1342],{},"示例：C# 多语句Lambda表达式",[61,1344,1347],{"className":1345,"code":1346,"language":129},[127],"(s, youngAge) =>{\n  Console.WriteLine(\"在主体中包含多个语句的Lambda表达式\");\n    \n  Return s.Age >= youngAge;}\n",[68,1348,1346],{"__ignoreMap":66},[10,1350,1351],{},"示例：VB.Net多语句Lambda表达式",[61,1353,1356],{"className":1354,"code":1355,"language":129},[127],"Function(s , youngAge)\n    \n    Console.WriteLine(\"在主体中包含多个语句的Lambda表达式\")\n    \n    Return s.Age >= youngAge\n\nEnd Function\n",[68,1357,1355],{"__ignoreMap":66},[31,1359,1361],{"id":1360},"在lambda表达主体中声明局部变量","在Lambda表达主体中声明局部变量",[10,1363,1364],{},"您可以在表达式主体中声明一个变量，以在表达式主体中的任何地方使用它，如下所示：",[10,1366,1367],{},"示例：C＃中的Lambda表达式局部变量",[61,1369,1372],{"className":1370,"code":1371,"language":129},[127],"s =>\n{   int youngAge = 18;\n\n    Console.WriteLine(\"在主体中包含多个语句的Lambda表达式\");\n\n    return s.Age >= youngAge;\n}\n",[68,1373,1371],{"__ignoreMap":66},[10,1375,1376],{},"示例：VB.Net Lambda表达式中的局部变量",[61,1378,1381],{"className":1379,"code":1380,"language":129},[127],"Function(s) \n                                      \n        Dim youngAge As Integer = 18\n            \n        Console.WriteLine(\"在主体中包含多个语句的Lambda表达式\")\n            \n        Return s.Age >= youngAge\n            \nEnd Function\n",[68,1382,1380],{"__ignoreMap":66},[10,1384,1385],{},"Lambda表达式也可以分配给内置委托，例如Func，Action和Predicate。",[10,1387,1388,1389,1392,1393,1395],{},"在 C# 中，直接调用 ",[68,1390,1391],{},".ToString()"," 方法可能无法提供你期望的结果，特别是在处理集合类型（如 ",[68,1394,1129],{},"）时。让我们详细解释一下原因以及为什么你需要其他方法来转换集合为字符串。",[36,1397,1399,1401],{"id":1398},"tostring-方法的行为",[68,1400,1391],{}," 方法的行为",[103,1403,1404,1429],{},[106,1405,1406,1409,1410],{},[14,1407,1408],{},"默认实现",":\n",[113,1411,1412],{},[106,1413,1414,1415,1418,1419,1421,1422,1424,1425,1428],{},"对于大多数对象，",[68,1416,1417],{},"ToString()"," 方法返回对象的类型名称，而不是对象的实际内容。例如，",[68,1420,1129],{}," 的 ",[68,1423,1417],{}," 方法通常返回类似 ",[68,1426,1427],{},"System.Linq.Enumerable+WhereEnumerableIterator"," 的字符串，而不是集合中的实际元素。",[106,1430,1431,1409,1437],{},[14,1432,1433,1421,1435],{},[68,1434,1129],{},[68,1436,1417],{},[113,1438,1439],{},[106,1440,1441,1443,1444,1446],{},[68,1442,1129],{}," 是一个接口，它的 ",[68,1445,1417],{}," 方法不会将集合中的所有字符串连接成一个可读的格式。相反，它将返回接口的类型名称，这并不符合你的期望。",[704,1448,1450],{"id":1449},"linq-标准查询运算符","LINQ 标准查询运算符",[10,1452,1453,1454,1457,1458,1461],{},"LINQ中的标准查询运算符实际上是 ",[68,1455,1456],{},"IEnumerable\u003CT> and IQueryable\u003CT>","类型的扩展方法。它们在System.Linq.Enumerable和System.Linq.Queryable类中定义。LINQ中提供了50多个标准查询运算符，它们提供了不同的功能，例如",[14,1459,1460],{},"过滤，排序，分组，聚合，串联","等。",[31,1463,1464],{"id":1464},"查询语法中的标准查询运算符",[10,1466,1467,1464],{},[746,1468],{"alt":746,"src":946},[31,1470,1471],{"id":1471},"方法语法中的标准查询运算符",[10,1473,1474,1471],{},[746,1475],{"alt":746,"src":1476},"https:\u002F\u002Fwww.cainiaojc.com\u002Fstatic\u002Fupload\u002F201229\u002F1443321.png",[10,1478,1479],{},"查询语法中的标准查询运算符在编译时转换为扩展方法。所以两者都是一样的。",[10,1481,1482],{},"可以根据标准查询运算符提供的功能对其进行分类。下表列出了标准查询运算符的所有分类：",[1484,1485,1486,1500],"table",{},[1487,1488,1489],"thead",{},[1490,1491,1492,1497],"tr",{},[1493,1494,1496],"th",{"align":1495},"left","类别",[1493,1498,1499],{"align":1495},"标准查询运算符",[1501,1502,1503,1512,1520,1528,1536,1544,1552,1560,1568,1576,1584,1592,1600,1608],"tbody",{},[1490,1504,1505,1509],{},[1506,1507,1508],"td",{"align":1495},"过滤",[1506,1510,1511],{"align":1495},"Where, OfType",[1490,1513,1514,1517],{},[1506,1515,1516],{"align":1495},"排序",[1506,1518,1519],{"align":1495},"OrderBy, OrderByDescending, ThenBy, ThenByDescending, Reverse",[1490,1521,1522,1525],{},[1506,1523,1524],{"align":1495},"分组",[1506,1526,1527],{"align":1495},"GroupBy, ToLookup",[1490,1529,1530,1533],{},[1506,1531,1532],{"align":1495},"联合",[1506,1534,1535],{"align":1495},"GroupJoin, Join",[1490,1537,1538,1541],{},[1506,1539,1540],{"align":1495},"投射",[1506,1542,1543],{"align":1495},"Select, SelectMany",[1490,1545,1546,1549],{},[1506,1547,1548],{"align":1495},"聚合",[1506,1550,1551],{"align":1495},"Aggregate, Average, Count, LongCount, Max, Min, Sum",[1490,1553,1554,1557],{},[1506,1555,1556],{"align":1495},"修饰",[1506,1558,1559],{"align":1495},"All, Any, Contains",[1490,1561,1562,1565],{},[1506,1563,1564],{"align":1495},"元素",[1506,1566,1567],{"align":1495},"ElementAt, ElementAtOrDefault, First, FirstOrDefault, Last, LastOrDefault, Single, SingleOrDefault",[1490,1569,1570,1573],{},[1506,1571,1572],{"align":1495},"集合",[1506,1574,1575],{"align":1495},"Distinct, Except, Intersect, Union",[1490,1577,1578,1581],{},[1506,1579,1580],{"align":1495},"分区",[1506,1582,1583],{"align":1495},"Skip, SkipWhile, Take, TakeWhile",[1490,1585,1586,1589],{},[1506,1587,1588],{"align":1495},"串联",[1506,1590,1591],{"align":1495},"Concat",[1490,1593,1594,1597],{},[1506,1595,1596],{"align":1495},"相等",[1506,1598,1599],{"align":1495},"SequenceEqual",[1490,1601,1602,1605],{},[1506,1603,1604],{"align":1495},"范围状态",[1506,1606,1607],{"align":1495},"DefaultEmpty, Empty, Range, Repeat",[1490,1609,1610,1613],{},[1506,1611,1612],{"align":1495},"转换",[1506,1614,1615],{"align":1495},"AsEnumerable, AsQueryable, Cast, ToArray, ToDictionary, ToList",[704,1617,1619],{"id":1618},"linq-排序运算符-orderby和orderbydescending","LINQ 排序运算符 OrderBy和OrderByDescending",[10,1621,1622],{},"排序运算符以升序或降序排列集合的元素。LINQ包括以下排序运算符。",[1484,1624,1625,1635],{},[1487,1626,1627],{},[1490,1628,1629,1632],{},[1493,1630,1631],{"align":1495},"运算符",[1493,1633,1634],{"align":1495},"描述",[1501,1636,1637,1645,1653,1661,1669],{},[1490,1638,1639,1642],{},[1506,1640,1641],{"align":1495},"OrderBy",[1506,1643,1644],{"align":1495},"根据指定的字段按升序或降序对集合中的元素进行排序。",[1490,1646,1647,1650],{},[1506,1648,1649],{"align":1495},"OrderByDescending",[1506,1651,1652],{"align":1495},"根据指定的字段按降序对集合进行排序。仅在方法语法中有效。",[1490,1654,1655,1658],{},[1506,1656,1657],{"align":1495},"ThenBy",[1506,1659,1660],{"align":1495},"仅在方法语法中有效。用于按升序进行二次排序。",[1490,1662,1663,1666],{},[1506,1664,1665],{"align":1495},"ThenByDescending",[1506,1667,1668],{"align":1495},"仅在方法语法中有效。用于按降序进行二次排序。",[1490,1670,1671,1674],{},[1506,1672,1673],{"align":1495},"Reverse",[1506,1675,1676],{"align":1495},"仅在方法语法中有效。按相反顺序对集合排序。",[704,1678,1680],{"id":1679},"linq-转换运算符","LINQ 转换运算符",[10,1682,1683,1684,1687,1688,1691,1692,1694],{},"LINQ中的Conversion运算符可用于转换序列（集合）中元素的类型。转换运算符分为三种：",[14,1685,1686],{},"As","运算符（AsEnumerable和AsQueryable），",[14,1689,1690],{},"To","运算符（ToArray，ToDictionary，ToList和ToLookup）和",[14,1693,1612],{},"运算符（Cast和OfType）。",[10,1696,1697],{},"下表列出了所有转换运算符。",[1484,1699,1700,1709],{},[1487,1701,1702],{},[1490,1703,1704,1707],{},[1493,1705,1706],{"align":1495},"方法",[1493,1708,1634],{"align":1495},[1501,1710,1711,1719,1727,1735,1743,1751,1759,1767],{},[1490,1712,1713,1716],{},[1506,1714,1715],{"align":1495},"AsEnumerable",[1506,1717,1718],{"align":1495},"将输入序列作为 IEnumerable \u003C T> 返回",[1490,1720,1721,1724],{},[1506,1722,1723],{"align":1495},"AsQueryable",[1506,1725,1726],{"align":1495},"将IEnumerableto转换为IQueryable，以模拟远程查询提供程序",[1490,1728,1729,1732],{},[1506,1730,1731],{"align":1495},"Cast",[1506,1733,1734],{"align":1495},"将非泛型集合转换为泛型集合（IEnumerable到IEnumerable）",[1490,1736,1737,1740],{},[1506,1738,1739],{"align":1495},"OfType",[1506,1741,1742],{"align":1495},"基于指定类型筛选集合",[1490,1744,1745,1748],{},[1506,1746,1747],{"align":1495},"ToArray",[1506,1749,1750],{"align":1495},"将集合转换为数组",[1490,1752,1753,1756],{},[1506,1754,1755],{"align":1495},"ToDictionary",[1506,1757,1758],{"align":1495},"根据键选择器函数将元素放入 Dictionary 中",[1490,1760,1761,1764],{},[1506,1762,1763],{"align":1495},"ToList",[1506,1765,1766],{"align":1495},"将集合转换为 List",[1490,1768,1769,1772],{},[1506,1770,1771],{"align":1495},"ToLookup",[1506,1773,1774],{"align":1495},"将元素分组到 Lookup\u003CTKey,TElement>",[31,1776,1778],{"id":1777},"asenumerable和asqueryable方法","AsEnumerable和AsQueryable方法",[10,1780,1781,1782,978,1784,194],{},"AsEnumerable和AsQueryable方法分别将源对象转换或转换为",[68,1783,713],{},[68,1785,717],{},[704,1787,1789],{"id":1788},"linq-表达式树","LINQ 表达式树",[10,1791,1792],{},"您已在上一节中了解了表达式。现在，让我们在这里了解表达式树。",[10,1794,1795],{},"顾名思义，表达式树不过是按树状数据结构排列的表达式。表达式树中的每个节点都是一个表达式。例如，表达式树可用于表示数学公式x \u003Cy，其中x，\u003C和y将表示为表达式，并排列在树状结构中。",[10,1797,1798],{},"表达式树是lambda表达式的内存表示形式。它保存查询的实际元素，而不是查询的结果。",[10,1800,1801],{},"表达式树使lambda表达式的结构透明和显式。您可以与表达式树中的数据进行交互，就像与其他任何数据结构一样。",[10,1803,1804],{},"例如，看以下isTeenAgerExpr表达式：",[61,1806,1808],{"className":63,"code":1807,"language":65,"meta":66,"style":66},"Expression\u003CFunc\u003CStudent, bool>> isTeenAgerExpr = s => s.age > 12 && s.age \u003C 20;\n",[68,1809,1810],{"__ignoreMap":66},[71,1811,1812],{"class":73,"line":74},[71,1813,1807],{},[704,1815,1817],{"id":1816},"linq-into-关键字","LINQ into 关键字",[10,1819,1820],{},"在LINQ查询中使用into关键字可组成一个组或在select子句后继续查询。",[10,1822,1823],{},"示例：LINQ中的 into 关键字",[61,1825,1827],{"className":63,"code":1826,"language":65,"meta":66,"style":66},"var teenAgerStudents = from s in studentList\n    where s.age > 12 && s.age \u003C 20\n    select s\n        into teenStudents\n        where teenStudents.StudentName.StartsWith(\"B\")\n        select teenStudents;\n",[68,1828,1829,1834,1839,1844,1849,1854],{"__ignoreMap":66},[71,1830,1831],{"class":73,"line":74},[71,1832,1833],{},"var teenAgerStudents = from s in studentList\n",[71,1835,1836],{"class":73,"line":235},[71,1837,1838],{},"    where s.age > 12 && s.age \u003C 20\n",[71,1840,1841],{"class":73,"line":241},[71,1842,1843],{},"    select s\n",[71,1845,1846],{"class":73,"line":247},[71,1847,1848],{},"        into teenStudents\n",[71,1850,1851],{"class":73,"line":253},[71,1852,1853],{},"        where teenStudents.StudentName.StartsWith(\"B\")\n",[71,1855,1856],{"class":73,"line":259},[71,1857,1858],{},"        select teenStudents;\n",[10,1860,1861],{},"在上面的查询中，“into”关键字引入了一个新的范围变量teenStudents，因此第一个范围变量s超出范围。您可以使用新的范围变量在into关键字之后编写进一步的查询。",[36,1863,1864],{"id":1864},"基本用法",[10,1866,1867,1870],{},[68,1868,1869],{},"into"," 语句通常用于两个主要场景：",[103,1872,1873,1885],{},[106,1874,1875,1881,1882,1884],{},[14,1876,1877,1878,1880],{},"在 ",[68,1879,973],{}," 子句中创建中间结果集","： ",[68,1883,1869],{}," 可以用来将查询的结果存储在一个新的临时变量中，然后在这个变量上继续进行查询操作。",[106,1886,1887,1892,1893,1895,1896,1898],{},[14,1888,1877,1889,1880],{},[68,1890,1891],{},"select","： 你可以在 ",[68,1894,1891],{}," 子句中使用 ",[68,1897,1869],{},"，将结果存储到一个新的集合中，然后对这个集合应用额外的查询。",[36,1900,312],{"id":312},[10,1902,1903,1904,1907,1908,1911],{},"假设我们有一个 ",[68,1905,1906],{},"students"," 集合和一个 ",[68,1909,1910],{},"courses"," 集合：",[61,1913,1915],{"className":63,"code":1914,"language":65,"meta":66,"style":66},"public class Student\n{\n    public string Name { get; set; }\n    public int Age { get; set; }\n    public List\u003Cstring> Courses { get; set; }\n}\n\npublic class Course\n{\n    public string CourseName { get; set; }\n    public string Instructor { get; set; }\n}\n\n",[68,1916,1917,1922,1926,1931,1936,1941,1945,1949,1954,1958,1963,1968],{"__ignoreMap":66},[71,1918,1919],{"class":73,"line":74},[71,1920,1921],{},"public class Student\n",[71,1923,1924],{"class":73,"line":235},[71,1925,238],{},[71,1927,1928],{"class":73,"line":241},[71,1929,1930],{},"    public string Name { get; set; }\n",[71,1932,1933],{"class":73,"line":247},[71,1934,1935],{},"    public int Age { get; set; }\n",[71,1937,1938],{"class":73,"line":253},[71,1939,1940],{},"    public List\u003Cstring> Courses { get; set; }\n",[71,1942,1943],{"class":73,"line":259},[71,1944,304],{},[71,1946,1947],{"class":73,"line":266},[71,1948,263],{"emptyLinePlaceholder":262},[71,1950,1951],{"class":73,"line":272},[71,1952,1953],{},"public class Course\n",[71,1955,1956],{"class":73,"line":278},[71,1957,238],{},[71,1959,1960],{"class":73,"line":284},[71,1961,1962],{},"    public string CourseName { get; set; }\n",[71,1964,1965],{"class":73,"line":289},[71,1966,1967],{},"    public string Instructor { get; set; }\n",[71,1969,1970],{"class":73,"line":295},[71,1971,304],{},[10,1973,1974,1975,1977],{},"我们可以使用 ",[68,1976,1869],{}," 来简化复杂的查询。以下是一些示例：",[1979,1980,1982,1983,1985],"h4",{"id":1981},"示例-1-使用-into-创建中间结果集","示例 1: 使用 ",[68,1984,1869],{}," 创建中间结果集",[10,1987,1988],{},"假设我们想要先查询所有年龄大于 20 的学生，然后对这些学生进一步查询他们的课程：",[61,1990,1992],{"className":63,"code":1991,"language":65,"meta":66,"style":66},"var studentsWithCourses = from student in students\n                          where student.Age > 20\n                          into filteredStudents\n                          select new\n                          {\n                              StudentNames = filteredStudents.Select(s => s.Name),\n                              Courses = filteredStudents.SelectMany(s => s.Courses)\n                          };\n\n",[68,1993,1994,1999,2004,2009,2014,2019,2024,2029],{"__ignoreMap":66},[71,1995,1996],{"class":73,"line":74},[71,1997,1998],{},"var studentsWithCourses = from student in students\n",[71,2000,2001],{"class":73,"line":235},[71,2002,2003],{},"                          where student.Age > 20\n",[71,2005,2006],{"class":73,"line":241},[71,2007,2008],{},"                          into filteredStudents\n",[71,2010,2011],{"class":73,"line":247},[71,2012,2013],{},"                          select new\n",[71,2015,2016],{"class":73,"line":253},[71,2017,2018],{},"                          {\n",[71,2020,2021],{"class":73,"line":259},[71,2022,2023],{},"                              StudentNames = filteredStudents.Select(s => s.Name),\n",[71,2025,2026],{"class":73,"line":266},[71,2027,2028],{},"                              Courses = filteredStudents.SelectMany(s => s.Courses)\n",[71,2030,2031],{"class":73,"line":272},[71,2032,2033],{},"                          };\n",[2035,2036,2037],"style",{},"html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"title":66,"searchDepth":235,"depth":235,"links":2039},[2040,2057,2058,2059,2060,2061,2062,2063,2064,2065,2069,2070,2071],{"id":33,"depth":235,"text":34,"children":2041},[2042,2044,2045,2046,2048,2050,2052,2053,2055,2056],{"id":38,"depth":241,"text":2043},"1. 委托（Delegate）",{"id":101,"depth":241,"text":101},{"id":219,"depth":241,"text":219},{"id":315,"depth":241,"text":2047},"2. Lambda 表达式",{"id":353,"depth":241,"text":2049},"Func\u003CT1, T2, TResult> 解释",{"id":394,"depth":241,"text":2051},"3. 委托类型与 Lambda 表达式",{"id":453,"depth":241,"text":453},{"id":509,"depth":241,"text":2054},"更多 Func 类型",{"id":559,"depth":241,"text":559},{"id":673,"depth":241,"text":673},{"id":755,"depth":235,"text":756},{"id":787,"depth":235,"text":788},{"id":824,"depth":235,"text":824},{"id":854,"depth":235,"text":854},{"id":959,"depth":235,"text":824},{"id":1174,"depth":235,"text":824},{"id":1319,"depth":235,"text":1320},{"id":1335,"depth":235,"text":1336},{"id":1360,"depth":235,"text":1361,"children":2066},[2067],{"id":1398,"depth":241,"text":2068},".ToString() 方法的行为",{"id":1464,"depth":235,"text":1464},{"id":1471,"depth":235,"text":1471},{"id":1777,"depth":235,"text":1778,"children":2072},[2073,2074],{"id":1864,"depth":241,"text":1864},{"id":312,"depth":241,"text":312},"语言集成查询（LINQ）是.Net 3.5和Visual Studio 2008引入的功能强大的查询语言。LINQ可与C＃或Visual Basic一起使用，以查询不同的数据源。","md",{},"\u002Fcsharp\u002Flinq",{"description":2075},"csharp\u002Flinq","Px_Xp7RHytq7Z_VEJyZ-rNlTLQkYm2O52YJD4U5o0-k",1791042465176]