LINQ查询操作符

    ·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<T>集合；不延迟
    ·ToDictionary - 将集合转换为<K, V>集合；不延迟
Summary3.aspx.cs  
using System;  
using System.Data;  
using System.Configuration;  
using System.Collections;  
using System.Linq;  
using System.Web;  
using System.Web.Security;  
using System.Web.UI;  
using System.Web.UI.WebControls;  
using System.Web.UI.WebControls.WebParts;  
using System.Web.UI.HtmlControls;  
using System.Xml.Linq;  
  
using System.Collections.Generic;  
using DAL;  
  
public partial class LINQ_Summary3 : System.Web.UI.Page  
{  
    NorthwindDataContext _ctx = new NorthwindDataContext();  
    string[] _ary = null;  
  
    protected void Page_Load(object sender, EventArgs e)  
    {  
        _ary = new string[] { "asp.net", "csharp", "xhtml", "css", "javascript",   
            "wcf", "wpf", "silverlight", "linq", "wf",   
            "sqlserver", "asp.net ajax", "ssis", "ssas", "ssrs" };  
  
        // First - 返回集合中的第一个元素；不延迟  
        // FirstOrDefault - 返回集合中的第一个元素（如果没有则返回默认值）；不延迟  
        Summary_First_FirstOrDefault();  
  
        // Last - 返回集合中的最后一个元素；不延迟  
        // LastOrDefault - 返回集合中的最后一个元素（如果没有则返回默认值）  
        Summary_Last_LastOrDefault();  
  
        // ElementAt - 返回集合中指定索引的元素；不延迟  
        // ElementAtOrDefault - 返回集合中指定索引的元素（如果没有则返回默认值）；不延迟  
        Summary_ElementAt_ElementAtOrDefault();  
  
        // Contains - 判断集合中是否包含有某一元素；不延迟  
        Summary_Contains();  
  
        // Any - 判断集合中是否有元素满足某一条件；不延迟  
        Summary_Any();  
  
        // All - 判断集合中是否所有元素都满足某一条件；不延迟  
        Summary_All();  
  
        // Count - 返回集合中的元素个数，返回int；不延迟  
        // LongCount - 返回集合中的元素个数，返回long；不延迟  
        Summary_Count_LongCount();  
  
        // Sum - 集合应为数字类型集合，求其和；不延迟  
        Summary_Sum();  
  
        // Min - 返回集合的最小值；不延迟  
        Summary_Min();  
  
        // Max - 返回集合的最大值；不延迟  
        Summary_Max();  
  
        // Average - 集合应为数字类型集合，求其平均值；不延迟  
        Summary_Average();  
  
        // Aggregate - 根据输入的表达式获取一个聚合值；不延迟  
        Summary_Aggregate();  
  
        // Cast - 将集合转换为强类型集合；延迟  
        Summary_Cast();  
  
        // DefaultIfEmpty - 查询结果为空则返回默认值；延迟  
        Summary_DefaultIfEmpty();  
  
        // SequenceEqual - 判断两个集合是否相同；不延迟  
        Summary_SequenceEqual();  
  
        // OfType - 过滤集合中的指定类型；延迟  
        Summary_OfType();  
  
        // ToArray - 将集合转换为数组；不延迟  
        Summary_ToArray();  
  
        // ToList - 将集合转换为List<T>集合；不延迟  
        Summary_ToList();  
  
        // ToDictionary - 将集合转换为<K, V>集合；不延迟  
        Summary_ToDictionary();  
    }  
}  
First - 返回集合中的第一个元素；不延迟  
FirstOrDefault - 返回集合中的第一个元素（如果没有则返回默认值）；不延迟  
    /**//// <summary>  
    /// First - 返回集合中的第一个元素；不延迟  
    /// FirstOrDefault - 返回集合中的第一个元素（如果没有则返回默认值）；不延迟  
    /// </summary>  
    void Summary_First_FirstOrDefault()  
    {  
        string s = (from a in _ary  
                    select a).First(a => a.StartsWith("s"));  
        // string s = (from a in _ary  
        //             select a).FirstOrDefault(a => a.StartsWith("xxx"));  
        // s == null  
  
        result.InnerHtml += s + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
silverlight  
  
Last - 返回集合中的最后一个元素；不延迟  
LastOrDefault - 返回集合中的最后一个元素（如果没有则返回默认值）  
    /**//// <summary>  
    /// Last - 返回集合中的最后一个元素；不延迟  
    /// LastOrDefault - 返回集合中的最后一个元素（如果没有则返回默认值）  
    /// </summary>  
    void Summary_Last_LastOrDefault()  
    {  
        string s = (from a in _ary  
                    select a).Last(a => a.StartsWith("s"));  
        // string s = (from a in _ary  
        //             select a).LastOrDefault(a => a.StartsWith("sss"));  
        // s == null  
  
        result.InnerHtml += s + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
ssrs  
  
ElementAt - 返回集合中指定索引的元素；不延迟  
ElementAtOrDefault - 返回集合中指定索引的元素（如果没有则返回默认值）；不延迟  
    /**//// <summary>  
    /// ElementAt - 返回集合中指定索引的元素；不延迟  
    /// ElementAtOrDefault - 返回集合中指定索引的元素（如果没有则返回默认值）；不延迟  
    /// </summary>  
    void Summary_ElementAt_ElementAtOrDefault()  
    {  
        string s = (from a in _ary  
                    select a).ElementAt(3);  
        // string s = (from a in _ary  
        //             select a).ElementAtOrDefault(1000);  
        // s == null  
  
        result.InnerHtml += s + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
css  
  
Contains - 判断集合中是否包含有某一元素；不延迟  
    /**//// <summary>  
    /// Contains - 判断集合中是否包含有某一元素；不延迟  
    /// </summary>  
    void Summary_Contains()  
    {  
        bool b = (from a in _ary  
                  select a).Contains("javascript");  
  
        result.InnerHtml += b.ToString() + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
True  
  
Any - 判断集合中是否有元素满足某一条件；不延迟  
    /**//// <summary>  
    /// Any - 判断集合中是否有元素满足某一条件；不延迟  
    /// </summary>  
    void Summary_Any()  
    {  
        bool b = (from a in _ary  
                  select a).Any(p => p.Length > 10);  
  
        result.InnerHtml += b.ToString() + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
True  
  
All - 判断集合中是否所有元素都满足某一条件；不延迟  
    /**//// <summary>  
    /// All - 判断集合中是否所有元素都满足某一条件；不延迟  
    /// </summary>  
    void Summary_All()  
    {  
        bool b = (from a in _ary  
                  select a).All(p => p.Length > 10);  
  
        result.InnerHtml += b.ToString() + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
False  
  
Count - 返回集合中的元素个数，返回int；不延迟  
LongCount - 返回集合中的元素个数，返回long；不延迟  
    /**//// <summary>  
    /// Count - 返回集合中的元素个数，返回int；不延迟  
    /// LongCount - 返回集合中的元素个数，返回long；不延迟  
    /// </summary>  
    void Summary_Count_LongCount()  
    {  
        int i = (from a in _ary  
                 select a).Count(p => p.Length > 10);  
        // long i = (from a in _ary  
        //           select a).LongCount(p => p.Length > 10);  
  
        result.InnerHtml += i.ToString() + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
2  
  
Sum - 集合应为数字类型集合，求其和；不延迟  
    /**//// <summary>  
    /// Sum - 集合应为数字类型集合，求其和；不延迟  
    /// </summary>  
    void Summary_Sum()  
    {  
        int i = (from a in _ary  
                 select a.Length).Sum();  
  
        result.InnerHtml += i.ToString() + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
87  
  
Min - 返回集合的最小值；不延迟  
    /**//// <summary>  
    /// Min - 返回集合的最小值；不延迟  
    /// </summary>  
    void Summary_Min()  
    {  
        int i = (from a in _ary  
                 select a.Length).Min();  
  
        result.InnerHtml += i.ToString() + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
2  
  
Max - 返回集合的最大值；不延迟  
    /**//// <summary>  
    /// Max - 返回集合的最大值；不延迟  
    /// </summary>  
    void Summary_Max()  
    {  
        int i = (from a in _ary  
                 select a.Length).Max();  
  
        result.InnerHtml += i.ToString() + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
12  
  
Average - 集合应为数字类型集合，求其平均值；不延迟  
    /**//// <summary>  
    /// Average - 集合应为数字类型集合，求其平均值；不延迟  
    /// </summary>  
    void Summary_Average()  
    {  
        double d = (from a in _ary  
                    select a.Length).Average();  
  
        result.InnerHtml += d.ToString() + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
5.8  
  
Aggregate - 根据输入的表达式获取一个聚合值；不延迟  
    /**//// <summary>  
    /// Aggregate - 根据输入的表达式获取一个聚合值；不延迟  
    /// </summary>  
    void Summary_Aggregate()  
    {  
        // 以下算法的Aggregate相当于Sum  
        double d = (from a in _ary  
                    select a.Length).Aggregate((x, y) => x + y);  
  
        result.InnerHtml += d.ToString() + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
87  
  
Cast - 将集合转换为强类型集合；延迟  
    /**//// <summary>  
    /// Cast - 将集合转换为强类型集合；延迟  
    /// </summary>  
    void Summary_Cast()  
    {  
        ArrayList al = new ArrayList();  
        al.Add("asp.net");  
        al.Add("csharp");  
        al.Add("xhtml");  
  
        var list = al.Cast<string>();  
  
        foreach (string s in list)  
        {  
            result.InnerHtml += s + "<br />";  
        }  
        result.InnerHtml += "<br />";  
    }运行结果  
asp.net  
csharp  
xhtml  
  
DefaultIfEmpty - 查询结果为空则返回默认值；延迟  
    /**//// <summary>  
    /// DefaultIfEmpty - 查询结果为空则返回默认值；延迟  
    /// </summary>  
    void Summary_DefaultIfEmpty()  
    {  
        var list = (from a in _ary  
                    where a.Length > 100  
                    select a).DefaultIfEmpty("xxx");  
  
        foreach (string s in list)  
        {  
            result.InnerHtml += s + "<br />";  
        }  
        result.InnerHtml += "<br />";  
    }运行结果  
xxx  
  
SequenceEqual - 判断两个集合是否相同；不延迟  
    /**//// <summary>  
    /// SequenceEqual - 判断两个集合是否相同；不延迟  
    /// </summary>  
    void Summary_SequenceEqual()  
    {  
        bool b = (from a in _ary  
                  where a.Length > 10  
                  select a).SequenceEqual(from a in _ary  
                                          where a.Length > 10  
                                          select a);  
  
        result.InnerHtml += b.ToString() + "<br />";  
        result.InnerHtml += "<br />";  
    }运行结果  
True  
  
OfType - 过滤集合中的指定类型；延迟  
    /**//// <summary>  
    /// OfType - 过滤集合中的指定类型；延迟  
    /// </summary>  
    void Summary_OfType()  
    {  
        object[] objects = { 1, "a", 2, "b", 3, "c" };  
  
        var list = objects.OfType<string>();  
  
        foreach (string s in list)  
        {  
            result.InnerHtml += s + "<br />";  
        }  
        result.InnerHtml += "<br />";  
    }运行结果  
a  
b  
c  
  
ToArray - 将集合转换为数组；不延迟  
    /**//// <summary>  
    /// ToArray - 将集合转换为数组；不延迟  
    /// </summary>  
    void Summary_ToArray()  
    {  
        string[] ary = (from p in _ctx.Products  
                        where p.ProductName.Length > 30  
                        select p.ProductName).ToArray();  
  
        foreach (string s in ary)  
        {  
            result.InnerHtml += s + "<br />";  
        }  
        result.InnerHtml += "<br />";  
    }运行结果  
Jack's New England Clam Chowder  
Louisiana Fiery Hot Pepper Sauce  
Original Frankfurter grüne So?e  
Uncle Bob's Organic Dried Pears  
  
ToList - 将集合转换为List<T>集合；不延迟  
    /**//// <summary>  
    /// ToList - 将集合转换为List<T>集合；不延迟  
    /// </summary>  
    void Summary_ToList()  
    {  
        var list = (from a in _ary  
                    where a.Length > 10  
                    select a).ToList();  
  
        foreach (string s in list)  
        {  
            result.InnerHtml += s + "<br />";  
        }  
        result.InnerHtml += "<br />";  
    }运行结果  
silverlight  
asp.net ajax  
  
ToDictionary - 将集合转换为<K, V>集合；不延迟  
    /**//// <summary>  
    /// ToDictionary - 将集合转换为<K, V>集合；不延迟  
    /// </summary>  
    void Summary_ToDictionary()  
    {  
        var dic = (from p in _ctx.Products  
                   where p.ProductName.Length > 30  
                   select p).ToDictionary(p => p.ProductID);  
  
        foreach (var p in dic)  
        {  
            result.InnerHtml += p.Key + "：" + p.Value.ProductName + "<br />";  
        }  
        result.InnerHtml += "<br />";  
    }运行结果  
7：Uncle Bob's Organic Dried Pears  
41：Jack's New England Clam Chowder  
65：Louisiana Fiery Hot Pepper Sauce  
77：Original Frankfurter grüne So?e