LINQ Learning-AggregateOperators、ConversionOperators等

AggregateOperators(聚合运算)　　　

　　  　Distinct：去除重复。

　　　　Count(n => n % 2 == 1)：n除以2余1的个数

　　　　Sum：加和。

　　　　Sum(w => w.Length)：字符串长度加和。

　　　　Min(最小)、Max(最大)、Average(平均)

　　　　Aggregate:将数组中的数依次进行运算。

　　　　eg1：

　　　　　  double[] doubles = { 1.7, 2.3, 1.9, 4.1, 2.9 };

　　　　　  double product = doubles.Aggregate((a, b) => a * b);

　　　　　　这个公式的意思是：1.7*2.3=>x*1.9=>x*4.1=>x*2.9=??,连起来就是 1.7*2.3*1.9*4.1*2.9=??

　　　　eg2:

　　　　　　double startBalance = 100.0;

　　　　　　int[] attemptedWithdrawals = { 20, 10, 40, 50, 10, 70, 30 };　　　　　　

　　　　　　double endBalance =attemptedWithdrawals.Aggregate(startBalance,(a, b) =>((b <= a) ? (a - b) : a));

　　　　　　这里相当于把100.00放到attemptedWithdrawals的第一位去运算。

　　　　　　100>20? 100-20=80

　　　　　　80>10? 80-10=70

　　　　　　70>40? 70-40=30

　　　　　　30>50?  30

　　　　　　30>10? 30-10=20

　　　　　　20>70? 20

　　　　　　20>30? 20

ConversionOperators

 　　　　ToDictionary:将数据变成字典

　　　　 eg:

　　　　　　　　var scoreRecords = new[] { new {Name = "Alice", Score = 50},
                                        new {Name = "Bob"  , Score = 40},
                                        new {Name = "Cathy", Score = 45}
                                    };
                var scoreRecordsDict = scoreRecords.ToDictionary(sr => sr.Name);

　　　　　　

　　　　OfType<T>:从数据中选择相应数据类型的数据。

　　　　eg：object[] numbers = { null, 1.0, "two", 3, "four", 5, "six", 7.0 };

　　　　var doubles = numbers.OfType<double>();     1  7

　　　　var doubles = numbers.OfType<string>();       two  four  six

CustomSequenceOperators(用户自定义操作)

　　　　Combine:

　　　　 eg:int NumberA={0,2,4,5,6,8,9}　　int NumberB={1,3,5,7,8}

　　　　  int dotProduct = numbersA.Combine(numbersB, (a, b) => a.Field<int>("number") * b.Field<int>("number")).Sum();

　　　　  0*1+2*3+4*5+5*7+6*8+8*0+9*0=109　　　　　　

public static IEnumerable<S> Combine<S>(this IEnumerable<DataRow> first, IEnumerable<DataRow> second, System.Func<DataRow, DataRow, S> func)
        {
            using (IEnumerator<DataRow> e1 = first.GetEnumerator(), e2 = second.GetEnumerator())
            {
                while (e1.MoveNext() && e2.MoveNext())
                {
                    yield return func(e1.Current, e2.Current);
                }
            }
        }

　　　　　　MoveNext:是否有下一个元素

ElementOperators

　　　　ElementAt(n)：第n个数据对象。

GenerationOperators

　　　　Enumerable.Range(100, 50)  从100开始 向后50个数，即从100到150

　　　　 Enumerable.Repeat(7, 10)    将7循环10次

MiscellaneousOperators

　　　　Concat:

　　　　　　　　int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 };

　　　　　　　　int[] numbersB = { 1, 3, 5, 7, 8 };

　　　　　　　　var allNumbers = numbersA.Concat(numbersB);   { 0, 2, 4, 5, 6, 8, 9,1, 3, 5, 7, 8}

　　　　 SequenceEqual：元素的个数，顺序，每个元素是否都相等　　　　　　　　

　　　　　　　　var wordsA = new string[] { "cherry", "apple", "blueberry" };　　　　　　　　　　　

　　　　　　　　var wordsB = new string[] { "cherry", "apple", "blueberry" };　　　　　　　　　var wordsB = new string[] { "apple", "blueberry", "cherry" };　　　　　

　　　　　　　　bool match = wordsA.SequenceEqual(wordsB);     true　　　　　　　　　　　　bool match = wordsA.SequenceEqual(wordsB);     false

OrderingOperators　　　　

　　　　  eg1:先按长度排序，再按首字母排序　　　　　　　　

　　　　　　　　  string[] digits = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
                var sortedDigits =
                    from digit in digits
                    orderby digit.Length, digit
                    select digit;　　　　　　　　　　

var sortedWords = words.OrderBy(a => a.Length)
                        .ThenBy(a => a, new CaseInsensitiveComparer());

　　　　　Reverse()：将结果集 倒序。　

PartitioningOperators

　　　　TakeWhile：不符合条件时就终止　　　　　

　　　　　　　　int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };

　　　　　　　　TakeWhile(n=>n<6)　　　　　　5, 4, 1, 3

　　　　　　　　Where(n=>n<6)　　　　　　     5, 4, 1, 3, 2, 0

　　　　  SkipWhile：符合条件时就停止跳过

　　　　　　　　int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };

　　　　　　　　SkipWhile(n => n % 3 != 0) 　　3, 9, 8, 6, 7, 2, 0 因为3符合了条件，后面的就都不跳过了