189 8069 5689

LINQ查询操作符

LINQ查询操作符之First、FirstOrDefault、Last、LastOrDefault、ElementAt、ElementAtOrDefault、Contains、Any、All、Coun

成都创新互联专注于米林企业网站建设,成都响应式网站建设,商城网站定制开发。米林网站建设公司,为米林等地区提供建站服务。全流程按需规划网站,专业设计,全程项目跟踪,成都创新互联专业和态度为您提供的服务

介绍  

  ·First - 返回集合中的第一个元素;不延迟  

  ·FirstOrDefault - 返回集合中的第一个元素(如果没有则返回默认值);不延迟  

  ·Last - 返回集合中的最后一个元素;不延迟  

  ·LastOrDefault - 返回集合中的最后一个元素(如果没有则返回默认值)  

  ·ElementAt - 返回集合中指定索引的元素;不延迟  

  ·ElementAtOrDefault - 返回集合中指定索引的元素(如果没有则返回默认值);不延迟  

  ·Contains - 判断集合中是否包含有某一元素;不延迟  

  ·Any - 判断集合中是否有元素满足某一条件;不延迟  

  ·All - 判断集合中是否所有元素都满足某一条件;不延迟  

  ·Count - 返回集合中的元素个数,返回int;不延迟  

  ·LongCount - 返回集合中的元素个数,返回long;不延迟  

  ·Sum - 集合应为数字类型集合,求其和;不延迟  

  ·Min - 返回集合的最小值;不延迟  

  ·Max - 返回集合的最大值;不延迟  

  ·Average - 集合应为数字类型集合,求其平均值;不延迟  

  ·Aggregate - 根据输入的表达式获取一个聚合值;不延迟  

  ·Cast - 将集合转换为强类型集合;延迟  

  ·DefaultIfEmpty - 查询结果为空则返回默认值;延迟  

  ·SequenceEqual - 判断两个集合是否相同;不延迟  

  ·OfType - 过滤集合中的指定类型;延迟  

  ·ToArray - 将集合转换为数组;不延迟  

  ·ToList - 将集合转换为List集合;不延迟  

  ·ToDictionary - 将集合转换为集合;不延迟  

  1. 示例  

  1. Summary3.aspx.cs  

  2. using System;  

  3. using System.Data;  

  4. using System.Configuration;  

  5. using System.Collections;  

  6. using System.Linq;  

  7. using System.Web;  

  8. using System.Web.Security;  

  9. using System.Web.UI;  

  10. using System.Web.UI.WebControls;  

  11. using System.Web.UI.WebControls.WebParts;  

  12. using System.Web.UI.HtmlControls;  

  13. using System.Xml.Linq;  

  14.   

  15. using System.Collections.Generic;  

  16. using DAL;  

  17.   

  18. public partial class LINQ_Summary3 : System.Web.UI.Page  

  19. {  

  20.     NorthwindDataContext _ctx = new NorthwindDataContext();  

  21.     string[] _ary = null;  

  22.   

  23.     protected void Page_Load(object sender, EventArgs e)  

  24.     {  

  25.         _ary = new string[] { "asp.net", "csharp", "xhtml", "css", "javascript",   

  26.             "wcf", "wpf", "silverlight", "linq", "wf",   

  27.             "sqlserver", "asp.net ajax", "ssis", "ssas", "***s" };  

  28.   

  29.         // First - 返回集合中的第一个元素;不延迟  

  30.         // FirstOrDefault - 返回集合中的第一个元素(如果没有则返回默认值);不延迟  

  31.         Summary_First_FirstOrDefault();  

  32.   

  33.         // Last - 返回集合中的最后一个元素;不延迟  

  34.         // LastOrDefault - 返回集合中的最后一个元素(如果没有则返回默认值)  

  35.         Summary_Last_LastOrDefault();  

  36.   

  37.         // ElementAt - 返回集合中指定索引的元素;不延迟  

  38.         // ElementAtOrDefault - 返回集合中指定索引的元素(如果没有则返回默认值);不延迟  

  39.         Summary_ElementAt_ElementAtOrDefault();  

  40.   

  41.         // Contains - 判断集合中是否包含有某一元素;不延迟  

  42.         Summary_Contains();  

  43.   

  44.         // Any - 判断集合中是否有元素满足某一条件;不延迟  

  45.         Summary_Any();  

  46.   

  47.         // All - 判断集合中是否所有元素都满足某一条件;不延迟  

  48.         Summary_All();  

  49.   

  50.         // Count - 返回集合中的元素个数,返回int;不延迟  

  51.         // LongCount - 返回集合中的元素个数,返回long;不延迟  

  52.         Summary_Count_LongCount();  

  53.   

  54.         // Sum - 集合应为数字类型集合,求其和;不延迟  

  55.         Summary_Sum();  

  56.   

  57.         // Min - 返回集合的最小值;不延迟  

  58.         Summary_Min();  

  59.   

  60.         // Max - 返回集合的最大值;不延迟  

  61.         Summary_Max();  

  62.   

  63.         // Average - 集合应为数字类型集合,求其平均值;不延迟  

  64.         Summary_Average();  

  65.   

  66.         // Aggregate - 根据输入的表达式获取一个聚合值;不延迟  

  67.         Summary_Aggregate();  

  68.   

  69.         // Cast - 将集合转换为强类型集合;延迟  

  70.         Summary_Cast();  

  71.   

  72.         // DefaultIfEmpty - 查询结果为空则返回默认值;延迟  

  73.         Summary_DefaultIfEmpty();  

  74.   

  75.         // SequenceEqual - 判断两个集合是否相同;不延迟  

  76.         Summary_SequenceEqual();  

  77.   

  78.         // OfType - 过滤集合中的指定类型;延迟  

  79.         Summary_OfType();  

  80.   

  81.         // ToArray - 将集合转换为数组;不延迟  

  82.         Summary_ToArray();  

  83.   

  84.         // ToList - 将集合转换为List集合;不延迟  

  85.         Summary_ToList();  

  86.   

  87.         // ToDictionary - 将集合转换为集合;不延迟  

  88.         Summary_ToDictionary();  

  89.     }  

  90. }  

  91. First - 返回集合中的第一个元素;不延迟  

  92. FirstOrDefault - 返回集合中的第一个元素(如果没有则返回默认值);不延迟  

  93.     /**//// 

      

  94.     /// First - 返回集合中的第一个元素;不延迟  

  95.     /// FirstOrDefault - 返回集合中的第一个元素(如果没有则返回默认值);不延迟  

  96.     ///   

  97.     void Summary_First_FirstOrDefault()  

  98.     {  

  99.         string s = (from a in _ary  

  100.                     select a).First(a => a.StartsWith("s"));  

  101.         // string s = (from a in _ary  

  102.         //             select a).FirstOrDefault(a => a.StartsWith("xxx"));  

  103.         // s == null  

  104.   

  105.         result.InnerHtml += s + "";  

  106.         result.InnerHtml += "";  

  107.     }运行结果  

  108. silverlight  

  109.   

  110. Last - 返回集合中的最后一个元素;不延迟  

  111. LastOrDefault - 返回集合中的最后一个元素(如果没有则返回默认值)  

  112.     /**//// 

      

  113.     /// Last - 返回集合中的最后一个元素;不延迟  

  114.     /// LastOrDefault - 返回集合中的最后一个元素(如果没有则返回默认值)  

  115.     ///   

  116.     void Summary_Last_LastOrDefault()  

  117.     {  

  118.         string s = (from a in _ary  

  119.                     select a).Last(a => a.StartsWith("s"));  

  120.         // string s = (from a in _ary  

  121.         //             select a).LastOrDefault(a => a.StartsWith("sss"));  

  122.         // s == null  

  123.   

  124.         result.InnerHtml += s + "";  

  125.         result.InnerHtml += "";  

  126.     }运行结果  

  127. ***s  

  128.   

  129. ElementAt - 返回集合中指定索引的元素;不延迟  

  130. ElementAtOrDefault - 返回集合中指定索引的元素(如果没有则返回默认值);不延迟  

  131.     /**//// 

      

  132.     /// ElementAt - 返回集合中指定索引的元素;不延迟  

  133.     /// ElementAtOrDefault - 返回集合中指定索引的元素(如果没有则返回默认值);不延迟  

  134.     ///   

  135.     void Summary_ElementAt_ElementAtOrDefault()  

  136.     {  

  137.         string s = (from a in _ary  

  138.                     select a).ElementAt(3);  

  139.         // string s = (from a in _ary  

  140.         //             select a).ElementAtOrDefault(1000);  

  141.         // s == null  

  142.   

  143.         result.InnerHtml += s + "";  

  144.         result.InnerHtml += "";  

  145.     }运行结果  

  146. css  

  147.   

  148. Contains - 判断集合中是否包含有某一元素;不延迟  

  149.     /**//// 

      

  150.     /// Contains - 判断集合中是否包含有某一元素;不延迟  

  151.     ///   

  152.     void Summary_Contains()  

  153.     {  

  154.         bool b = (from a in _ary  

  155.                   select a).Contains("javascript");  

  156.   

  157.         result.InnerHtml += b.ToString() + "";  

  158.         result.InnerHtml += "";  

  159.     }运行结果  

  160. True  

  161.   

  162. Any - 判断集合中是否有元素满足某一条件;不延迟  

  163.     /**//// 

      

  164.     /// Any - 判断集合中是否有元素满足某一条件;不延迟  

  165.     ///   

  166.     void Summary_Any()  

  167.     {  

  168.         bool b = (from a in _ary  

  169.                   select a).Any(p => p.Length > 10);  

  170.   

  171.         result.InnerHtml += b.ToString() + "";  

  172.         result.InnerHtml += "";  

  173.     }运行结果  

  174. True  

  175.   

  176. All - 判断集合中是否所有元素都满足某一条件;不延迟  

  177.     /**//// 

      

  178.     /// All - 判断集合中是否所有元素都满足某一条件;不延迟  

  179.     ///   

  180.     void Summary_All()  

  181.     {  

  182.         bool b = (from a in _ary  

  183.                   select a).All(p => p.Length > 10);  

  184.   

  185.         result.InnerHtml += b.ToString() + "";  

  186.         result.InnerHtml += "";  

  187.     }运行结果  

  188. False  

  189.   

  190. Count - 返回集合中的元素个数,返回int;不延迟  

  191. LongCount - 返回集合中的元素个数,返回long;不延迟  

  192.     /**//// 

      

  193.     /// Count - 返回集合中的元素个数,返回int;不延迟  

  194.     /// LongCount - 返回集合中的元素个数,返回long;不延迟  

  195.     ///   

  196.     void Summary_Count_LongCount()  

  197.     {  

  198.         int i = (from a in _ary  

  199.                  select a).Count(p => p.Length > 10);  

  200.         // long i = (from a in _ary  

  201.         //           select a).LongCount(p => p.Length > 10);  

  202.   

  203.         result.InnerHtml += i.ToString() + "";  

  204.         result.InnerHtml += "";  

  205.     }运行结果  

  206. 2  

  207.   

  208. Sum - 集合应为数字类型集合,求其和;不延迟  

  209.     /**//// 

      

  210.     /// Sum - 集合应为数字类型集合,求其和;不延迟  

  211.     ///   

  212.     void Summary_Sum()  

  213.     {  

  214.         int i = (from a in _ary  

  215.                  select a.Length).Sum();  

  216.   

  217.         result.InnerHtml += i.ToString() + "";  

  218.         result.InnerHtml += "";  

  219.     }运行结果  

  220. 87  

  221.   

  222. Min - 返回集合的最小值;不延迟  

  223.     /**//// 

      

  224.     /// Min - 返回集合的最小值;不延迟  

  225.     ///   

  226.     void Summary_Min()  

  227.     {  

  228.         int i = (from a in _ary  

  229.                  select a.Length).Min();  

  230.   

  231.         result.InnerHtml += i.ToString() + "";  

  232.         result.InnerHtml += "";  

  233.     }运行结果  

  234. 2  

  235.   

  236. Max - 返回集合的最大值;不延迟  

  237.     /**//// 

      

  238.     /// Max - 返回集合的最大值;不延迟  

  239.     ///   

  240.     void Summary_Max()  

  241.     {  

  242.         int i = (from a in _ary  

  243.                  select a.Length).Max();  

  244.   

  245.         result.InnerHtml += i.ToString() + "";  

  246.         result.InnerHtml += "";  

  247.     }运行结果  

  248. 12  

  249.   

  250. Average - 集合应为数字类型集合,求其平均值;不延迟  

  251.     /**//// 

      

  252.     /// Average - 集合应为数字类型集合,求其平均值;不延迟  

  253.     ///   

  254.     void Summary_Average()  

  255.     {  

  256.         double d = (from a in _ary  

  257.                     select a.Length).Average();  

  258.   

  259.         result.InnerHtml += d.ToString() + "";  

  260.         result.InnerHtml += "";  

  261.     }运行结果  

  262. 5.8  

  263.   

  264. Aggregate - 根据输入的表达式获取一个聚合值;不延迟  

  265.     /**//// 

      

  266.     /// Aggregate - 根据输入的表达式获取一个聚合值;不延迟  

  267.     ///   

  268.     void Summary_Aggregate()  

  269.     {  

  270.         // 以下算法的Aggregate相当于Sum  

  271.         double d = (from a in _ary  

  272.                     select a.Length).Aggregate((x, y) => x + y);  

  273.   

  274.         result.InnerHtml += d.ToString() + "";  

  275.         result.InnerHtml += "";  

  276.     }运行结果  

  277. 87  

  278.   

  279. Cast - 将集合转换为强类型集合;延迟  

  280.     /**//// 

      

  281.     /// Cast - 将集合转换为强类型集合;延迟  

  282.     ///   

  283.     void Summary_Cast()  

  284.     {  

  285.         ArrayList al = new ArrayList();  

  286.         al.Add("asp.net");  

  287.         al.Add("csharp");  

  288.         al.Add("xhtml");  

  289.   

  290.         var list = al.Cast();  

  291.   

  292.         foreach (string s in list)  

  293.         {  

  294.             result.InnerHtml += s + "";  

  295.         }  

  296.         result.InnerHtml += "";  

  297.     }运行结果  

  298. asp.net  

  299. csharp  

  300. xhtml  

  301.   

  302. DefaultIfEmpty - 查询结果为空则返回默认值;延迟  

  303.     /**//// 

      

  304.     /// DefaultIfEmpty - 查询结果为空则返回默认值;延迟  

  305.     ///   

  306.     void Summary_DefaultIfEmpty()  

  307.     {  

  308.         var list = (from a in _ary  

  309.                     where a.Length > 100  

  310.                     select a).DefaultIfEmpty("xxx");  

  311.   

  312.         foreach (string s in list)  

  313.         {  

  314.             result.InnerHtml += s + "";  

  315.         }  

  316.         result.InnerHtml += "";  

  317.     }运行结果  

  318. xxx  

  319.   

  320. SequenceEqual - 判断两个集合是否相同;不延迟  

  321.     /**//// 

      

  322.     /// SequenceEqual - 判断两个集合是否相同;不延迟  

  323.     ///   

  324.     void Summary_SequenceEqual()  

  325.     {  

  326.         bool b = (from a in _ary  

  327.                   where a.Length > 10  

  328.                   select a).SequenceEqual(from a in _ary  

  329.                                           where a.Length > 10  

  330.                                           select a);  

  331.   

  332.         result.InnerHtml += b.ToString() + "";  

  333.         result.InnerHtml += "";  

  334.     }运行结果  

  335. True  

  336.   

  337. OfType - 过滤集合中的指定类型;延迟  

  338.     /**//// 

      

  339.     /// OfType - 过滤集合中的指定类型;延迟  

  340.     ///   

  341.     void Summary_OfType()  

  342.     {  

  343.         object[] objects = { 1, "a", 2, "b", 3, "c" };  

  344.   

  345.         var list = objects.OfType();  

  346.   

  347.         foreach (string s in list)  

  348.         {  

  349.             result.InnerHtml += s + "";  

  350.         }  

  351.         result.InnerHtml += "";  

  352.     }运行结果  

  353. a  

  354. b  

  355. c  

  356.   

  357. ToArray - 将集合转换为数组;不延迟  

  358.     /**//// 

      

  359.     /// ToArray - 将集合转换为数组;不延迟  

  360.     ///   

  361.     void Summary_ToArray()  

  362.     {  

  363.         string[] ary = (from p in _ctx.Products  

  364.                         where p.ProductName.Length > 30  

  365.                         select p.ProductName).ToArray();  

  366.   

  367.         foreach (string s in ary)  

  368.         {  

  369.             result.InnerHtml += s + "";  

  370.         }  

  371.         result.InnerHtml += "";  

  372.     }运行结果  

  373. Jack's New England Clam Chowder  

  374. Louisiana Fiery Hot Pepper Sauce  

  375. Original Frankfurter grüne So?e  

  376. Uncle Bob's Organic Dried Pears  

  377.   

  378. ToList - 将集合转换为List集合;不延迟  

  379.     /**//// 

      

  380.     /// ToList - 将集合转换为List集合;不延迟  

  381.     ///   

  382.     void Summary_ToList()  

  383.     {  

  384.         var list = (from a in _ary  

  385.                     where a.Length > 10  

  386.                     select a).ToList();  

  387.   

  388.         foreach (string s in list)  

  389.         {  

  390.             result.InnerHtml += s + "";  

  391.         }  

  392.         result.InnerHtml += "";  

  393.     }运行结果  

  394. silverlight  

  395. asp.net ajax  

  396.   

  397. ToDictionary - 将集合转换为集合;不延迟  

  398.     /**//// 

      

  399.     /// ToDictionary - 将集合转换为集合;不延迟  

  400.     ///   

  401.     void Summary_ToDictionary()  

  402.     {  

  403.         var dic = (from p in _ctx.Products  

  404.                    where p.ProductName.Length > 30  

  405.                    select p).ToDictionary(p => p.ProductID);  

  406.   

  407.         foreach (var p in dic)  

  408.         {  

  409.             result.InnerHtml += p.Key + ":" + p.Value.ProductName + "";  

  410.         }  

  411.         result.InnerHtml += "";  

  412.     }运行结果  

  413. 7:Uncle Bob's Organic Dried Pears  

  414. 41:Jack's New England Clam Chowder  

  415. 65:Louisiana Fiery Hot Pepper Sauce  

  416. 77:Original Frankfurter grüne So?e  


当前文章:LINQ查询操作符
网页链接:http://cdxtjz.com/article/ijgdeg.html

其他资讯