介绍

·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