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", "s-s-rs" }; 
 
                // 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 />"; 
        }