Linq To Object

//SelectMany
            List<List<int>> Numbers = new List<List<int>>()
            {
            new List<int>{1,2,3},
            new List<int>{4,5,6},
            new List<int>{7,8,9}
            
            };

            var result = Numbers.SelectMany(a => a);
            foreach (var nubers in result)
            {
                Console.WriteLine(nubers);
            }

            int[][] intarry = { new int[] { 1, 2, 3 }, new int[] { 4, 5, 6 }, new int[] { 7, 8, 9 } };
            var result = intarry.SelectMany(a => a);
            foreach (var nubers in result)
            {
                Console.WriteLine(nubers);
            }

//Take:返回指定的元素个数=>从左至右
            string[] arry = new string[] { "1", "2", "3", "4", "5" };
            var result = (from query in arry select query).Take(2);
            //var result= arry.Take(2);
            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//TakeWhile:返回连续满足条件的元素=>从左至右
            string[] arry = new string[] { "1234", "2345", "345", "456", "567" };
            var item = (from query in arry select query).TakeWhile(q => q.Length>3);
            //var item = arry.TakeWhile(q => q.Length==4);
            foreach (var it in item)
            {
                Console.WriteLine(it);
            }

//Skip:跳过指定的元素个数=>从左至右
            string[] ary = new string[] { "asp.net", "csharp","22", "xhtml", "css", "javascript", "wcf", "wpf", 
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight"};
            var result = (from query in ary select query).Skip(8);
            //var result = ary.Skip(8);
            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//SkipWhile:跳过连续满足条件的元素
            string[] ary = new string[] { "asp.net", "csharp","22", "xhtml", "css", "javascript", "wcf", "wpf", 
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight"};
            var result = ary.SkipWhile(q => q.Length > 3).TakeWhile(q => q.Length >= 2).Take(5);
            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//Concat:连接不同集合，不会自动过滤相同项
            string[] ary = new string[] { "asp.net", "csharp","22", "xhtml", "css", "javascript", "wcf", "wpf", 
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight", 
                                           "linq", "wf", "sqlserver", "asp.net ajax", "ssis", "ssas", "ssrs"
            };
            string[] arry = new string[] { "1234", "2345", "345", "456", "567" };
            var result = ary.Concat(arry);
            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//OrderBy:正序排列
            string[] ary = new string[] { "asp.net", "csharp","22", "xhtml", "css", "javascript", "wcf", "wpf", 
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight" };
            var result = ary.OrderBy(q => q.Length);
            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//OrderByDescending:倒序排列
            string[] ary = new string[] { "asp.net", "csharp","22", "xhtml", "css", "javascript", "wcf", "wpf", 
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight", 
                                           "linq", "wf", "sqlserver", "asp.net ajax", "ssis", "ssas", "ssrs"
            };
            var result = ary.OrderByDescending(q => q.Length);
            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//ThenBy:对OrderBy与OrderByDescending排序的结果再进行以特定的条件进行正序排序
            string[] ary = new string[] { "asp.net", "csharp","22", "xhtml", "css", "javascript", "wcf", "wpf", 
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight" };
            var result = ary.OrderByDescending(q=>q.Length).ThenBy(q =>q);
            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//Distinct:过滤集合中的相同项;
            string[] ary = new string[] { "asp.net", "csharp","22", "xhtml", "css", "javascript", "wcf", "wpf", 
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight", 
                                           "linq", "wf", "sqlserver", "asp.net ajax", "ssis", "ssas", "ssrs"
            };
            var result = ary.Distinct();
            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//Union:连接不同集合，自动过滤相同项;
            string[] ary = new string[] { "asp.net", "csharp","22","456", "xhtml", "css", "javascript", "wcf", "wpf", 
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight", 
                                           "linq", "wf", "sqlserver", "asp.net ajax", "ssis", "ssas", "ssrs"
            };
            string[] arry = new string[] { "1234", "2345", "345", "456", "567", "asp.net", "asp.net ajax", };
            var result = ary.Union(arry);
            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//Intersect:获取不同集合的相同项(交集)
            string[] ary = new string[] { "asp.net", "csharp","22","456", "xhtml", "css", "javascript", "wcf", "wpf", 
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight", 
                                           "linq", "wf", "sqlserver", "asp.net ajax", "ssis", "ssas", "ssrs"
            };
            string[] arry = new string[] { "1234", "2345", "345", "456", "567", "asp.net", "asp.net ajax", };
            var result = ary.Intersect(arry);
            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//Except:从某集合中删除其与另一个集合中相同的项,并消除自身的重复项
            string[] ary = new string[] { "asp.net", "csharp","22","456", "xhtml", "css", "javascript", "wcf", "wpf", 
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight", 
                                           "linq", "wf", "sqlserver", "asp.net ajax", "ssis", "ssas", "ssrs"
            };
            string[] arry = new string[] { "1234", "2345", "345", "456", "567", "asp.net", "asp.net ajax", };
            var result = ary.Except(arry);
            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//Single:根据表达式返回集合中的某一元素
            string[] ary = { "css", "javascript", "sqlserver"};
            //var result = ary.Single(q => q == "sqlserver" || q[2] == 'l');
            var result = (from query in ary select query).Single(q => q == "sqlserver" || q[2] == 'l');
            foreach (var it in result)
            {
                Console.Write(it);
            }

//SingleOrDefault:根据表达式返回集合中的某一元素(如果没有则返回默认值)
            string[] ary = new string[] {"22","456", "wcf", "wpf", 
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight", 
                                           "linq", "wf", "sqlserver", "asp.net ajax", "ssis", "ssas", "ssrs"
            };
            var result="";
            result = ary.SingleOrDefault(q => q == "javascript");
            
            foreach (var it in result)
            {
                Console.Write(it);
            }

//Reverse:对集合反向排序
            string[] ary = new string[] {"22","456", "wcf", "wpf","wpf","wpf","wpf","wpf", 
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight", 
                                           "linq", "wf", "sqlserver", "asp.net ajax", "ssis", "ssas", "ssrs"
            };
            var result = ary.Reverse();

            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//Join:用来连接两个输入序列
            string[] ary = new string[] {"22","456", "wcf", "wpf",
                                           "asp.net", "csharp", "xhtml", "css", "javascript","silverlight", 
                                           "linq", "wf", "sqlserver", "asp.net ajax", "ssis", "ssas", "ssrs"
            };
            string[] arry = new string[] {  "456", "asp.net", "asp.net ajax" };
            var result = from _query in ary
                         join query in arry on _query equals query
                         select _query;

            foreach (var it in result)
            {
                Console.WriteLine(it);
            }

//Cast:Cast操作符将类型为IEnumerable的集合对象转换成为IEnumerable<T>类型的集合对象
            ArrayList arraylist = new ArrayList();
            arraylist.Add("1111");
            arraylist.Add("222");
            arraylist.Add("3333");
            IEnumerable<string> IE = arraylist.Cast<string>().Where(A => A.Length > 3);
            foreach (string item in IE)
            {
                Console.WriteLine(item);
            }
            //结果：1111 3333

//ToArray:将一个输入序列转换成一个数组
            List<string> list = new List<string>();
            list.AddRange(new List<string>
            {
                "1","2","3","4","5"
            });
            string[] str = list.ToArray();

//ToList:操作符用于将一个输入序列转换成一个List<T>（System.Collections.Generic.List<T>）对象。
            string[] arry = new string[] { "456", "asp.net", "asp.net ajax" };
            List<string> str = arry.ToList();

//ToDictionary:操作符用于将一个输入序列转换成一个Dictionary<K,T>（System.Collections.Generic. Dictionary<K,T>）集合对象
List<Class> cla=new List<Class>();
            for (int i = 0; i < 10; i++)
            {
                cla.Add(new Class { ClassID = i, ClassName = i.ToString(), StudentNumber = i + 30 });
            }

            Dictionary<int, string> dic = cla.ToDictionary(new Func<Class, int>(A => A.ClassID), new Func<Class, string>(B => B.ClassName));
            foreach (var item in dic.Keys)
            {
                Response.Write(item+"<br/>");
            }

//ToLookup:操作符可以将一个输入序列转换成一个ILookup<K,T> （System.Linq.ILookup<K,T>）集合对象。ILookup<K,T>集合对象与Dictionary<K,T>集合对象非常相似，不同的是，在Dictionary<K,T>中一个键（key）只能对应一个元素；而在ILookup<K,T>中，一个键可以对应一组元素（一个序列）。
List<Class> cla = new List<Class>();
            for (int i = 0; i < 10; i++)
            {
                cla.Add(new Class { ClassID = i, ClassName = i.ToString(), StudentNumber = i + 30 });
            }
            ILookup<int,string> Lookup= cla.ToLookup(new Func<Class, int>(A => A.ClassID), new Func<Class, string>(B => B.ClassName));
            foreach (var item in Lookup)
            {
                Response.Write(item.Key + "<br/>");
            }

//SequenceEqual:判断两个序列是否相等
            int[] arr = { 4, 5, 6 };
            int[] array = { 4, 5, 6 };
            bool b = arr.SequenceEqual(array);
            Console.WriteLine(b);

//First:返回输入序列的第一个元素或者满足条件的第一个元素
            string[] arr = { "4", "52", "666666666" };
            string str = arr.First(A => A.Length > 5);
            Console.WriteLine(str);
　　　　　　　　//结果：666666666

//FirstOrDefault:操作符的使用与First操作符非常相似，只是在没有找到元素时，First操作符会抛出一个异常对象，而FirstOrDefault操作符会返回一个相关类型默认值元素
            string[] arr = { "4", "52", "66666" };
            string array= arr.FirstOrDefault(new Func<string, bool>(A => A.Length>5));
            Console.WriteLine(array);

//Last操作符用于返回输入序列的最后一个元素或者满足条件的最后一个元素
string[] arr = { "4", "52", "666666666" };
            string str = arr.Last(A => A.Length > 5);
            Console.WriteLine(str);

//LastOrDefault操作符的使用与Last操作符非常相似，只是在没有找到元素时，Last操作符会抛出一个异常对象，而LastOrDefault操作符会返回一个相关类型默认值元素

string[] arr = { "4", "52", "6666666" };
            string array = arr.LastOrDefault(new Func<string, bool>(A => A.Length > 5));
            Console.WriteLine(array);

//Single操作符用于从一个只含有一个元素的输入序列中返回唯一的元素或者满足特定条件的唯一元素。如果输入序列中的元素个数为零或者多于一个，Single操作符会抛出一个异常
string[] arr = { "4", "52", "6666666" };
            string array = arr.Single(new Func<string, bool>(A => A.Length > 5));
            Console.WriteLine(array);

//SingleOrDefault操作符的使用与Single操作符非常相似，只是在没有找到元素时，Single操作符会抛出一个异常对象，而SingleOrDefault操作符会返回一个相关类型默认值元素
string[] arr = { "4", "52", "6666655" };
            string array = arr.SingleOrDefault(new Func<string, bool>(A => A.Length > 5));
            Console.WriteLine(array);

//ElementAt操作符用于返回输入序列中指定位置的元素
string[] arr = { "4", "52", "6666655" };
            string array = arr.ElementAt(2);
            Console.WriteLine(array);

//ElementAtOrDefault操作符的使用与ElementAt操作符非常相似，只是在指定的位置索引值不合法的情况下（小于0或者大于或等于序列元素个数），ElementAt操作符会抛出一个异常对象，而ElementAtOrDefault操作符会返回一个相关类型默认值元素
string[] arr = { "4", "52", "6666655" };
            string array = arr.ElementAtOrDefault(3);
            Console.WriteLine(array);

//Any:操作符用于判断一个输入序列中是否含有元素或者含有满足特定条件的元素
            string[] arr = { "4", "52", "6666655" };
            bool b = arr.Any(new Func<string, bool>(A => A.Length == 8));
            Console.WriteLine(b);

            //结果：False

//All操作符用于判断输入序列中的所有元素是否全部满足指定条件

string[] arr = { "4", "52", "6666655" };
            bool b= arr.All(new Func<string, bool>(A => A.GetType() == typeof(string)));
            Console.WriteLine(b);

            //结果：True

//Count:操作符用于获取输入序列的元素个数或者满足某个特定条件的元素个数
            string[] arr = { "4", "52", "6666655" };
            int I = arr.Count(new Func<string, bool>(A => A.Length > 2));
            Console.WriteLine(I);

            //结果：1

//Sum：计算输入序列中所有元素数值总和
            int[] arr = { 4, 52, 66};
            int SUN = arr.Sum(new Func<int, int>(A => A));
            Console.WriteLine(SUN);

            //结果：122

DataSet ds = Common.SqlDataAdapter(ConnStr.connStr, "select * from View_Salary", null);
var select = from query in ds.Tables[0].AsEnumerable() where query.Field<int>("Salary") > 0 select query;
int SumSalary = select.Sum(query => query.Field<int>("Salary"));
return SumSalary;

//Min:获取输入序列中所有元素的最小值
int[] arr = { 4, 52, 66};
            int SUN = arr.Min(new Func<int, int>(A => A));
            Console.WriteLine(SUN);

            //结果：4

//Max:操作符用于获取输入序列中所有元素的最大值
int[] arr = { 4, 52, 66};
            int SUN = arr.Max(new Func<int, int>(A => A));
            Console.WriteLine(SUN);

            //结果：66

//Average:操作符用于计算输入序列中全体元素的平均值
int[] arr = { 4, 52, 66};
            double SUN = arr.Average(new Func<int, int>(A => A));
            Console.WriteLine(SUN);

            //结果：40.6666666666667

//Select
var persons = new List<Person> { 
            new Person{userName="action", age=11},
            new Person{userName="Boolean", age=26},
            new Person{userName="new",age=25},
            };
            //var v = from fm in persons where fm.age > 20 select fm.userName.ToUpper();
            var v = persons.Where(fm => fm.age > 20).Select(fm => fm.userName.ToUpper());
            foreach (var item in v)
            {
                Console.WriteLine(item.ToString());
            }

//AsEnumerable与orderby...ascending,正序
DataSet ds = Common.SqlDataAdapter(ConnStr.connStr, "select * from View_Salary", null);
            var select = from query in ds.Tables[0].AsEnumerable() orderby query.Field<int>("Salary") ascending select query;
            DataTable MyDataTable = select.CopyToDataTable<DataRow>();
            return MyDataTable;

//orderby...descending,倒序
DataSet ds = Common.SqlDataAdapter(ConnStr.connStr, "select * from View_Salary", null);
            var select = from query in ds.Tables[0].AsEnumerable() orderby query.Field<int>("Salary") descending select query;
            DataTable MyDataTable = select.CopyToDataTable<DataRow>();
            return MyDataTable;