步步为营VS 2008 + .NET 3.5(6) - LINQ查询操作符之Distinct、Union、Concat、Intersect、Except

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_Summary2 : 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",    
                         "asp.net",  "csharp",  "xhtml",  "css",  "javascript",    
                         "silverlight",  "linq",  "wf",  "sqlserver",  "asp.net ajax",  "ssis",  "ssas",  "ssrs" }; 
 
                 // Distinct - 过滤集合中的相同项；延迟 
                Summary_Distinct(); 
 
                 // Union - 连接不同集合，自动过滤相同项；延迟 
                Summary_Union(); 
 
                 // Concat - 连接不同集合，不会自动过滤相同项；延迟 
                Summary_Concat(); 
 
                 // Intersect - 获取不同集合的相同项（交集）；延迟 
                Summary_Intersect(); 
 
                 // Except - 从某集合中删除其与另一个集合中相同的项；延迟 
                Summary_Except(); 
 
                 // Skip - 跳过集合的前n个元素；延迟 
                 // Take - 获取集合的前n个元素；延迟 
                Summary_Skip_Take(); 
 
                 // SkipWhile - 直到某一条件成立就停止跳过；延迟 
                 // TakeWhile - 直到某一条件成立就停止获取；延迟 
                Summary_SkipWhile_TakeWhile(); 
 
                 // Single - 根据表达式返回集合中的某一元素；不延迟 
                 // SingleOrDefault - 根据表达式返回集合中的某一元素（如果没有则返回默认值）；不延迟 
                Summary_Single_SingleOrDefault(); 
 
                 // Reverse - 对集合反向排序；延迟 
                Summary_Reverse(); 
 
                 // SelectMany - Select选择（一对多）；延迟 
                Summary_SelectMany(); 
        } 
}

/// <summary> 
         /// Distinct - 过滤集合中的相同项；延迟 
         /// </summary> 
         void Summary_Distinct() 
        { 
                var ary = (from a  in _ary 
                                     select a).Distinct(); 
 
                 foreach ( string s  in ary) 
                { 
                        result.InnerHtml += s +  "<br />"; 
                } 
                result.InnerHtml +=  "<br />"; 
        }

/// <summary> 
         /// Union - 连接不同集合，自动过滤相同项；延迟 
         /// </summary> 
         void Summary_Union() 
        { 
                var ary = (from a  in _ary 
                                     select a).Take(3).Union((from a  in _ary 
                                                                                        select a).Take(6)); 
 
                 foreach ( string s  in ary) 
                { 
                        result.InnerHtml += s +  "<br />"; 
                } 
                result.InnerHtml +=  "<br />"; 
        }

/// <summary> 
         /// Concat - 连接不同集合，不会自动过滤相同项；延迟 
         /// </summary> 
         void Summary_Concat() 
        { 
                var ary = (from a  in _ary 
                                     select a).Take(3).Concat((from a  in _ary 
                                                                                         select a).Take(6)); 
 
                 foreach ( string s  in ary) 
                { 
                        result.InnerHtml += s +  "<br />"; 
                } 
                result.InnerHtml +=  "<br />"; 
        }

  /// <summary> 
         /// Intersect - 获取不同集合的相同项（交集）；延迟 
         /// </summary> 
         void Summary_Intersect() 
        { 
                var ary = (from a  in _ary 
                                     select a).Take(3).Intersect((from a  in _ary 
                                                                                                select a).Skip(1).Take(3)); 
 
                 foreach ( string s  in ary) 
                { 
                        result.InnerHtml += s +  "<br />"; 
                } 
                result.InnerHtml +=  "<br />"; 
        }

/// <summary> 
         /// Except - 从某集合中删除其与另一个集合中相同的项；延迟 
         /// </summary> 
         void Summary_Except() 
        { 
                var ary = (from a  in _ary 
                                     select a).Take(3).Except((from a  in _ary 
                                                                                         select a).Skip(1).Take(3)); 
 
                 foreach ( string s  in ary) 
                { 
                        result.InnerHtml += s +  "<br />"; 
                } 
                result.InnerHtml +=  "<br />"; 
        }

  /// <summary> 
         /// Skip - 跳过集合的前n个元素；延迟 
         /// Take - 获取集合的前n个元素；延迟 
         /// </summary> 
         void Summary_Skip_Take() 
        { 
                var ary = (from a  in _ary 
                                     select a).Skip(2).Take(3); 
 
                 foreach ( string s  in ary) 
                { 
                        result.InnerHtml += s +  "<br />"; 
                } 
                result.InnerHtml +=  "<br />"; 
        }

/// <summary> 
         /// SkipWhile - 直到某一条件成立就停止跳过；延迟 
         /// TakeWhile - 直到某一条件成立就停止获取；延迟 
         /// </summary> 
         void Summary_SkipWhile_TakeWhile() 
        { 
                var ary = (from a  in _ary 
                                     select a).SkipWhile(s => s.Length < 8).TakeWhile(s => s.Length > 2); 
 
                 foreach ( string s  in ary) 
                { 
                        result.InnerHtml += s +  "<br />"; 
                } 
                result.InnerHtml +=  "<br />"; 
        }

  /// <summary> 
         /// Single - 根据表达式返回集合中的某一元素；不延迟 
         /// SingleOrDefault - 根据表达式返回集合中的某一元素（如果没有则返回默认值）；不延迟 
         /// </summary> 
         void Summary_Single_SingleOrDefault() 
        { 
                 string s = (from a  in _ary 
                                        select a).Single(a => a ==  "silverlight"); 
                 // string s = (from a in _ary 
                 //                         select a).SingleOrDefault(a => a == "xxx"); 
                 // s == null 
 
                result.InnerHtml += s +  "<br />"; 
                result.InnerHtml +=  "<br />"; 
        }

  /// <summary> 
         /// Reverse - 对集合反向排序；延迟 
         /// </summary> 
         void Summary_Reverse() 
        { 
                var ary = (from a  in _ary 
                                     orderby a.Length ascending 
                                     select a).Reverse(); 
 
                 foreach ( string s  in ary) 
                { 
                        result.InnerHtml += s +  "<br />"; 
                } 
                result.InnerHtml +=  "<br />"; 
        }

/// <summary> 
         /// SelectMany - Select选择（一对多）；延迟 
         /// </summary> 
         void Summary_SelectMany() 
        { 
                var ary = (from a  in _ary 
                                     where a.Contains( ".") 
                                     select a).SelectMany(a => a.Split('.')); 
 
                 foreach ( string s  in ary) 
                { 
                        result.InnerHtml += s +  "<br />"; 
                } 
                result.InnerHtml +=  "<br />"; 
        }