101个LINQ示例，包含几乎全部操作

    Restriction Operators  
    Where - Simple 1  
    public void Linq1() {  
        int[] numbers = { 5,4,1,3,9,8,6,7,2,0 };  
        var lowNums =  
            from n in numbers  
            where n < 5  
            select n;  
        Console.WriteLine("Numbers < 5:");  
        foreach (var x in lowNums) {  
            Console.WriteLine(x);  
        }  
    }  
      
    Where - Simple 2  
    public void Linq2() {  
        List products = GetProductList();  
        var soldOutProducts =  
            from p in products  
            where p.UnitsInStock == 0  
            select p;  
        Console.WriteLine("Sold out products:");  
        foreach (var product in soldOutProducts) {  
            Console.WriteLine("{0} is sold out!",product.ProductName);  
        }  
    }  
      
    Where - Simple 3  
    public void Linq3() {  
        List products = GetProductList();  
        var expensiveInStockProducts =  
            from p in products  
            where p.UnitsInStock > 0 && p.UnitPrice > 3.00M  
            select p;  
        Console.WriteLine("In-stock products that cost more than 3.00:");  
        foreach (var product in expensiveInStockProducts) {  
            Console.WriteLine("{0} is in stock and costs more than 3.00.",product.ProductName);  
        }  
    }  
      
    Where - Drilldown  
    public void Linq4() {  
        List customers = GetCustomerList();  
        var waCustomers =  
            from c in customers  
            where c.Region == "WA"  
            select c;  
        Console.WriteLine("Customers from Washington and their orders:");  
        foreach (var customer in waCustomers) {  
            Console.WriteLine("Customer {0}: {1}",customer.CustomerID,customer.CompanyName);  
            foreach (var order in customer.Orders) {  
                Console.WriteLine(" Order {0}: {1}",order.OrderID,order.OrderDate);  
            }  
        }  
    }  
      
    Where - Indexed  
    public void Linq5() {  
        string[] digits = { "zero","one","two","three","four","five","six","seven","eight","nine" };  
        var shortDigits = digits.Where((digit,index) => digit.Length < index);  
        Console.WriteLine("Short digits:");  
        foreach (var d in shortDigits) {  
            Console.WriteLine("The word {0} is shorter than its value.",d);  
        }  
    }  
      
    Projection Operators  
    Select - Simple 1  
    public void Linq6() {  
        int[] numbers = { 5,0 };  
        var numsPlusOne =  
            from n in numbers  
            select n + 1;  
        Console.WriteLine("Numbers + 1:");  
        foreach (var i in numsPlusOne) {  
            Console.WriteLine(i);  
        }  
    }  
      
    Select - Simple 2  
    public void Linq7() {  
        List products = GetProductList();  
        var productNames =  
            from p in products  
            select p.ProductName;  
        Console.WriteLine("Product Names:");  
        foreach (var productName in productNames) {  
            Console.WriteLine(productName);  
        }  
    }  
      
    Select - Transformation  
    public void Linq8() {  
        int[] numbers = { 5,0 };  
        string[] strings = { "zero","nine" };  
        var textNums =   
            from n in numbers  
            select strings[n];  
        Console.WriteLine("Number strings:");  
        foreach (var s in textNums) {  
            Console.WriteLine(s);  
        }           
    }  
      
    Select - Anonymous Types 1  
    public void Linq9() {  
        string[] words = { "aPPLE","BlUeBeRrY","cHeRry" };  
        var upperLowerWords =  
            from w in words  
            select new {Upper = w.ToUpper(),Lower = w.ToLower()};  
        foreach (var ul in upperLowerWords) {  
            Console.WriteLine("Uppercase: {0},Lowercase: {1}",ul.Upper,ul.Lower);  
        }  
    }  
      
    Select - Anonymous Types 2  
    public void Linq10() {  
        int[] numbers = { 5,"nine" };  
        var digitOddEvens =  
            from n in numbers  
            select new {Digit = strings[n],Even = (n % 2 == 0)};  
        foreach (var d in digitOddEvens) {  
            Console.WriteLine("The digit {0} is {1}.",d.Digit,d.Even ? "even" : "odd");  
        }  
    }  
      
    Select - Anonymous Types 3  
    public void Linq11() {  
        List products = GetProductList();  
        var productInfos =  
            from p in products  
            select new {p.ProductName,p.Category,Price = p.UnitPrice};  
        Console.WriteLine("Product Info:");  
        foreach (var productInfo in productInfos) {  
            Console.WriteLine("{0} is in the category {1} and costs {2} per unit.",productInfo.ProductName,productInfo.Category,productInfo.Price);  
        }  
    }  
      
    Select - Indexed  
    public void Linq12() {  
        int[] numbers = { 5,0 };  
        var numsInPlace = numbers.Select((num,index) => new {Num = num,InPlace = (num == index)});  
        Console.WriteLine("Number: In-place?");  
        foreach (var n in numsInPlace) {  
            Console.WriteLine("{0}: {1}",n.Num,n.InPlace);  
        }  
    }  
      
    Select - Filtered  
    public void Linq13() {  
        int[] numbers = { 5,0 };  
        string[] digits = { "zero","nine" };  
        var lowNums =  
            from n in numbers  
            where n < 5  
            select digits[n];  
        Console.WriteLine("Numbers < 5:");  
        foreach (var num in lowNums) {  
            Console.WriteLine(num);  
        }       
    }  
      
    SelectMany - Compound from 1  
    public void Linq14() {  
        int[] numbersA = { 0,5,9 };  
        int[] numbersB = { 1,8 };  
        var pairs =  
            from a in numbersA,b in numbersB  
            where a < b  
            select new {a,b};  
        Console.WriteLine("Pairs where a < b:");  
        foreach (var pair in pairs) {  
            Console.WriteLine("{0} is less than {1}",pair.a,pair.b);  
        }  
    }  
      
    SelectMany - Compound from 2  
    public void Linq15() {  
        List customers = GetCustomerList();  
        var orders =  
            from c in customers,o in c.Orders  
            where o.Total < 500.00M  
            select new {c.CustomerID,o.OrderID,o.Total};  
        ObjectDumper.Write(orders);  
    }  
      
    SelectMany - Compound from 3  
    public void Linq16() {  
        List customers = GetCustomerList();  
        var orders =  
            from c in customers,o in c.Orders  
            where o.OrderDate >= new DateTime(1998,1)  
            select new {c.CustomerID,o.OrderDate};  
        ObjectDumper.Write(orders);  
    }  
      
    SelectMany - from Assignment  
    public void Linq17() {  
        List customers = GetCustomerList();  
        var orders =  
            from c in customers,o in c.Orders,total = o.Total  
            where total >= 2000.0M  
            select new {c.CustomerID,total};  
        ObjectDumper.Write(orders);  
    }  
      
    SelectMany - Multiple from  
    public void Linq18() {  
        List customers = GetCustomerList();  
        DateTime cutoffDate = new DateTime(1997,1);  
        var orders =  
            from c in customers  
            where c.Region == "WA"  
            from o in c.Orders  
            where o.OrderDate >= cutoffDate  
            select new {c.CustomerID,o.OrderID};  
        ObjectDumper.Write(orders);  
    }  
      
    SelectMany - Indexed  
    public void Linq19() {  
        List customers = GetCustomerList();  
        var customerOrders =  
            customers.SelectMany(  
                (cust,custIndex) =>  
                cust.Orders.Select(o => "Customer #" + (custIndex + 1) +  
                                        " has an order with OrderID " + o.OrderID) );  
        ObjectDumper.Write(customerOrders);  
    }  
      
    Partitioning Operators  
    Take - Simple  
    public void Linq20() {  
                int[] numbers = { 5,0 };  
                var first3Numbers = numbers.Take(3);  
                Console.WriteLine("First 3 numbers:");  
                foreach (var n in first3Numbers) {  
                    Console.WriteLine(n);  
                }  
            }  
      
    Take - Nested  
    public void Linq21() {  
                List<Customer> customers = GetCustomerList();  
                var first3WAOrders = (  
                    from c in customers  
                    from o in c.Orders  
                    where c.Region == "WA"  
                    select new {c.CustomerID,o.OrderDate} )  
                    .Take(3);  
                Console.WriteLine("First 3 orders in WA:");  
                foreach (var order in first3WAOrders) {  
                    ObjectDumper.Write(order);  
                }  
            }  
      
    Skip - Simple  
    public void Linq22() {  
                int[] numbers = { 5,0 };  
                var allButFirst4Numbers = numbers.Skip(4);  
                Console.WriteLine("All but first 4 numbers:");  
                foreach (var n in allButFirst4Numbers) {  
                    Console.WriteLine(n);  
                }  
            }  
      
    Skip - Nested  
    public void Linq23() {  
                List<Customer> customers = GetCustomerList();  
                var waOrders =  
                    from c in customers  
                    from o in c.Orders  
                    where c.Region == "WA"  
                    select new {c.CustomerID,o.OrderDate};  
                var allButFirst2Orders = waOrders.Skip(2);  
                Console.WriteLine("All but first 2 orders in WA:");  
                foreach (var order in allButFirst2Orders) {  
                    ObjectDumper.Write(order);  
                }  
            }  
      
    TakeWhile - Simple  
    public void Linq24() {  
                int[] numbers = { 5,0 };  
                var firstNumbersLessThan6 = numbers.TakeWhile(n => n < 6);  
                Console.WriteLine("First numbers less than 6:");  
                foreach (var n in firstNumbersLessThan6) {  
                    Console.WriteLine(n);  
                }  
            }  
      
    SkipWhile - Simple  
    public void Linq26() {  
                int[] numbers = { 5,0 };  
                var allButFirst3Numbers = numbers.SkipWhile(n => n % 3 != 0);  
                Console.WriteLine("All elements starting from first element divisible by 3:");  
                foreach (var n in allButFirst3Numbers) {  
                    Console.WriteLine(n);  
                }  
            }  
      
    SkipWhile - Indexed  
    public void Linq27() {  
                int[] numbers = { 5,0 };  
                var laterNumbers = numbers.SkipWhile((n,index) => n >= index);  
                Console.WriteLine("All elements starting from first element less than its position:");  
                foreach (var n in laterNumbers) {  
                    Console.WriteLine(n);  
                }  
            }  
      
    Ordering Operators  
    OrderBy - Simple 1  
    publicvoid Linq28() {  
        string[] words = { "cherry","apple","blueberry" };  
          
        var sortedWords =  
            from w in words  
            orderby w  
            select w;  
          
        Console.WriteLine("The sorted list of words:");  
        foreach (var w in sortedWords) {  
            Console.WriteLine(w);  
        }  
    }  
    OrderBy - Simple 2  
    public void Linq29() {  
        string[] words = { "cherry","blueberry" };  
        var sortedWords =  
            from w in words  
            orderby w.Length  
            select w;  
        Console.WriteLine("The sorted list of words (by length):");  
        foreach (var w in sortedWords) {  
            Console.WriteLine(w);  
        }  
    }  
      
    OrderBy - Simple 3  
    public void Linq30() {  
        List products = GetProductList();  
        var sortedProducts =  
            from p in products  
            orderby p.ProductName  
            select p;  
        ObjectDumper.Write(sortedProducts);  
    }  
      
    OrderBy - Comparer  
    public class CaseInsensitiveComparer : IComparer<string>  
    {  
        public int Compare(string x,string y)  
        {  
            return string.Compare(x,y,true);  
        }  
    }  
    public void Linq31() {  
        string[] words = { "aPPLE","AbAcUs","bRaNcH","ClOvEr","cHeRry"};  
        var sortedWords = words.OrderBy(a => a,new CaseInsensitiveComparer());  
        ObjectDumper.Write(sortedWords);  
    }  
      
    OrderByDescending - Simple 1  
    public void Linq32() {  
        double[] doubles = { 1.7,2.3,1.9,4.1,2.9 };  
        var sortedDoubles =  
            from d in doubles  
            orderby d descending  
            select d;  
        Console.WriteLine("The doubles from highest to lowest:");  
        foreach (var d in sortedDoubles) {  
            Console.WriteLine(d);  
        }  
    }  
      
    OrderByDescending - Simple 2  
    public void Linq33() {  
        List products = GetProductList();  
        var sortedProducts =  
            from p in products  
            orderby p.UnitsInStock descending  
            select p;  
        ObjectDumper.Write(sortedProducts);  
    }  
      
    OrderByDescending - Comparer  
    public class CaseInsensitiveComparer : IComparerspan class="qs-keyword">string>  
    {  
        publicint Compare(string x,string y)  
        {  
            returnstring.Compare(x,true);  
        }  
    }  
      
    publicvoid Linq34() {  
        string[] words = { "aPPLE","cHeRry"};  
          
        var sortedWords = words.OrderByDescending(a => a,new CaseInsensitiveComparer());  
              
        ObjectDumper.Write(sortedWords);  
    }  
    ThenBy - Simple  
    publicvoid Linq35() {  
        string[] digits = { "zero","nine" };  
      
        var sortedDigits =  
            from d in digits   
            orderby d.Length,d  
            select d;  
      
        Console.WriteLine("Sorted digits:");  
        foreach (var d in sortedDigits) {  
            Console.WriteLine(d);  
        }  
    }  
    ThenBy - Comparer  
    public class CaseInsensitiveComparer : IComparerspan class="qs-keyword">string>  
    {  
        publicint Compare(string x,true);  
        }  
    }  
      
    publicvoid Linq36() {  
        string[] words = { "aPPLE","cHeRry"};  
          
        var sortedWords =  
            words.OrderBy(a => a.Length)  
                    .ThenBy(a => a,new CaseInsensitiveComparer());  
              
        ObjectDumper.Write(sortedWords);  
    }  
    ThenByDescending - Simple  
    publicvoid Linq37() {  
        List products = GetProductList();var sortedProducts =  
            from p in products  
            orderby p.Category,p.UnitPrice descendingselect p;  
      
        ObjectDumper.Write(sortedProducts);  
    }  
    ThenByDescending - Comparer  
    public class CaseInsensitiveComparer : IComparerspan class="qs-keyword">string>  
    {  
        publicint Compare(string x,true);  
        }  
    }  
      
    publicvoid Linq38() {  
        string[] words = { "aPPLE","cHeRry"};  
          
        var sortedWords =  
            words.OrderBy(a => a.Length)  
                    .ThenByDescending(a => a,new CaseInsensitiveComparer());  
              
        ObjectDumper.Write(sortedWords);  
    }  
    Reverse  
    publicvoid Linq39() {  
        string[] digits = { "zero","nine" };  
          
        var reversedIDigits = (  
            from d in digits  
            where d[1] == 'i'  
            select d)  
            .Reverse();  
          
        Console.WriteLine("A backwards list of the digits with a second character of 'i':");  
        foreach (var d in reversedIDigits) {  
            Console.WriteLine(d);  
        }               
    }  
    Grouping Operators  
    GroupBy - Simple 1  
    public void Linq40() {  
                int[] numbers = { 5,0 };  
                var numberGroups =  
                    from n in numbers  
                    group n by n % 5 into g  
                    select new { Remainder = g.Key,Numbers = g };  
                foreach (var g in numberGroups) {  
                    Console.WriteLine("Numbers with a remainder of {0} when divided by 5:",g.Remainder);  
                    foreach (var n in g.Numbers) {  
                        Console.WriteLine(n);  
                    }  
                }  
    }  
      
    GroupBy - Simple 2  
    public void Linq41() {  
                string[] words = { "blueberry","chimpanzee","abacus","banana","cheese" };  
                var wordGroups =  
                    from w in words  
                    group w by w[0] into g  
                    select new { FirstLetter = g.Key,Words = g };  
                foreach (var g in wordGroups) {  
                    Console.WriteLine("Words that start with the letter '{0}':",g.FirstLetter);  
                    foreach (var w in g.Words) {  
                        Console.WriteLine(w);  
                    }  
                }  
            }  
      
    GroupBy - Simple 3  
    public void Linq42() {  
                List<Product> products = GetProductList();  
                var orderGroups =  
                    from p in products  
                    group p by p.Category into g  
                    select new { Category = g.Key,Products = g };  
                ObjectDumper.Write(orderGroups,1);  
            }  
      
    GroupBy - Nested  
    public void Linq43() {  
                List<Customer> customers = GetCustomerList();  
                var customerOrderGroups =   
                    from c in customers  
                    select  
                        new {c.CompanyName,YearGroups =  
                                 from o in c.Orders  
                                 group o by o.OrderDate.Year into yg  
                                 select  
                                     new {Year = yg.Key,MonthGroups =   
                                              from o in yg  
                                              group o by o.OrderDate.Month into mg  
                                              select new { Month = mg.Key,Orders = mg }  
                                         }  
                            };  
                ObjectDumper.Write(customerOrderGroups,3);  
            }  
      
    GroupBy - Comparer  
    public class AnagramEqualityComparer : IEqualityComparer   
    {   
    public bool Equals(string x,string y) { return getCanonicalString(x) == getCanonicalString(y); }   
    public int GetHashCode(string obj) { return getCanonicalString(obj).GetHashCode(); }   
    private string getCanonicalString(string word)   
    {   
        char[] wordChars = word.ToCharArray(); Array.Sort(wordChars); return new string(wordChars);   
    }   
    }   
      
      
    publicvoid Linq44()   
    {   
    string[] anagrams = {"from "," salt"," earn "," last "," near "," form "};   
    var orderGroups = anagrams.GroupBy(w => w.Trim(),new AnagramEqualityComparer());   
    ObjectDumper.Write(orderGroups,1);   
    }  
    GroupBy - Comparer,Mapped  
    public void Linq45() {  
                string[] anagrams = {"from "," form "};  
                var orderGroups = anagrams.GroupBy(  
                            w => w.Trim(),a => a.ToUpper(),new AnagramEqualityComparer()  
                            );  
                ObjectDumper.Write(orderGroups,1);  
            }  
    public class AnagramEqualityComparer : IEqualityComparer<string>  
            {  
                public bool Equals(string x,string y) {  
                    return getCanonicalString(x) == getCanonicalString(y);  
                }  
                public int GetHashCode(string obj) {  
                    return getCanonicalString(obj).GetHashCode();  
                }  
                private string getCanonicalString(string word) {  
                    char[] wordChars = word.ToCharArray();  
                    Array.Sort<char>(wordChars);  
                    return new string(wordChars);  
                }  
            }  
      
    Set Operators  
    Distinct - 1  
    publicvoid Linq46() {  
        int[] factorsOf300 = { 2,5 };  
          
        var uniqueFactors = factorsOf300.Distinct();  
      
        Console.WriteLine("Prime factors of 300:");  
        foreach (var f in uniqueFactors) {  
            Console.WriteLine(f);  
        }  
    }  
    Distinct - 2  
    public void Linq47() {  
        List products = GetProductList();  
        var categoryNames = (  
            from p in products  
            select p.Category)  
            .Distinct();  
                                                  
        Console.WriteLine("Category names:");  
        foreach (var n in categoryNames) {  
            Console.WriteLine(n);  
        }  
    }  
    Union - 1  
    publicvoid Linq48() {  
        int[] numbersA = { 0,8 };  
          
        var uniqueNumbers = numbersA.Union(numbersB);  
          
        Console.WriteLine("Unique numbers from both arrays:");  
        foreach (var n in uniqueNumbers) {  
            Console.WriteLine(n);  
        }  
    }  
    Union - 2  
    publicvoid Linq49() {  
        List products = GetProductList();List customers = GetCustomerList();  
          
        var productFirstChars =  
            from p in products  
            select p.ProductName[0];  
        var customerFirstChars =  
            from c in customers  
            select c.CompanyName[0];  
          
        var uniqueFirstChars = productFirstChars.Union(customerFirstChars);  
          
        Console.WriteLine("Unique first letters from Product names and Customer names:");  
        foreach (var ch in uniqueFirstChars) {  
            Console.WriteLine(ch);  
        }  
    }  
    Intersect - 1  
    publicvoid Linq50() {  
        int[] numbersA = { 0,8 };  
          
        var commonNumbers = numbersA.Intersect(numbersB);  
          
        Console.WriteLine("Common numbers shared by both arrays:");  
        foreach (var n in commonNumbers) {  
            Console.WriteLine(n);  
        }  
    }  
    Intersect - 2  
    publicvoid Linq51() {  
        List products = GetProductList();  
        List customers = GetCustomerList();  
          
        var productFirstChars =  
            from p in products  
            select p.ProductName[0];  
        var customerFirstChars =  
            from c in customers  
            select c.CompanyName[0];  
          
        var commonFirstChars = productFirstChars.Intersect(customerFirstChars);  
          
        Console.WriteLine("Common first letters from Product names and Customer names:");  
        foreach (var ch in commonFirstChars) {  
            Console.WriteLine(ch);  
        }  
    }  
    Except - 1  
    public void Linq52() {  
        int[] numbersA = { 0,8 };  
        IEnumerable<int> aOnlyNumbers = numbersA.Except(numbersB);  
        Console.WriteLine("Numbers in first array but not second array:");  
        foreach (var n in aOnlyNumbers) {  
            Console.WriteLine(n);  
        }  
    }  
      
    Except - 2  
    public void Linq53() {  
        List products = GetProductList();  
        List customers = GetCustomerList();  
        var productFirstChars =  
            from p in products  
            select p.ProductName[0];  
        var customerFirstChars =  
            from c in customers  
            select c.CompanyName[0];  
        var productOnlyFirstChars = productFirstChars.Except(customerFirstChars);  
        Console.WriteLine("First letters from Product names,but not from Customer names:");  
        foreach (var ch in productOnlyFirstChars) {  
            Console.WriteLine(ch);  
        }  
    }  
      
    Conversion Operators  
    To Array  
    public void Linq54() {  
        double[] doubles = { 1.7,2.9 };  
        var sortedDoubles =  
            from d in doubles  
            orderby d descending  
            select d;  
        var doublesArray = sortedDoubles.ToArray();  
        Console.WriteLine("Every other double from highest to lowest:");  
        for (int d = 0; d < doublesArray.Length; d += 2) {  
            Console.WriteLine(doublesArray[d]);  
        }   
    }  
      
    To List  
    public void Linq55() {  
        string[] words = { "cherry","blueberry" };  
        var sortedWords =  
            from w in words  
            orderby w  
            select w;  
        var wordList = sortedWords.ToList();  
        Console.WriteLine("The sorted word list:");  
        foreach (var w in wordList) {  
            Console.WriteLine(w);  
        }  
    }  
      
    To Dictionary  
    public void Linq56() {  
        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);  
        Console.WriteLine("Bob's score: {0}",scoreRecordsDict["Bob"]);  
    }  
      
    OfType  
    public void Linq57() {  
        object[] numbers = { null,1.0,4.0f,7.0 };  
        var doubles = numbers.OfType<double>();  
        Console.WriteLine("Numbers stored as doubles:");  
        foreach (var d in doubles) {  
            Console.WriteLine(d);  
        }  
    }  
      
    Element Operators  
    First - Simple  
    public void Linq58() {  
        List products = GetProductList();  
        Product product12 = (  
            from p in products  
            where p.ProductID == 12  
            select p )  
            .First();  
        ObjectDumper.Write(product12);  
    }  
      
    First - Indexed  
    public void Linq60() {  
        int[] numbers = { 5,0 };  
        int evenNum = numbers.First((num,index) => (num % 2 == 0) && (index % 2 == 0));  
        Console.WriteLine("{0} is an even number at an even position within the list.",evenNum);  
    }  
      
    FirstOrDefault - Simple  
    public void Linq61() {  
        int[] numbers = {};  
        int firstNumOrDefault = numbers.FirstOrDefault();  
        Console.WriteLine(firstNumOrDefault);  
    }  
      
    FirstOrDefault - Condition  
    public void Linq62() {  
        List products = GetProductList();  
        Product product789 = products.FirstOrDefault(p => p.ProductID == 789);  
        Console.WriteLine("Product 789 exists: {0}",product789 != null);  
    }  
      
    FirstOrDefault - Indexed  
    public void Linq63() {  
        double?[] doubles = { 1.7,2.9 };  
        double? num = doubles.FirstOrDefault((n,index) => (n >= index - 0.5 && n <= index + 0.5));  
        if (num != null)  
            Console.WriteLine("The value {1} is within 0.5 of its index position.",num);  
        else  
            Console.WriteLine("There is no number within 0.5 of its index position.",num);  
    }  
      
    ElementAt  
    public void Linq64() {  
        int[] numbers = { 5,0 };  
        int fourthLowNum = (  
            from n in numbers  
            where n < 5  
            select n )  
            .ElementAt(3); // 3 because sequences use 0-based indexing  
        Console.WriteLine("Fourth number < 5: {0}",fourthLowNum);  
    }  
      
    Generation Operators  
    Range  
    public void Linq65() {   
       var numbers =   
          from n in Sequence.Range(100,50)   
          selectnew {Number = n,OddEven = n % 2 == 1 ? "odd" : "even"};   
       foreach (var n in numbers) {   
          Console.WriteLine("The number {0} is {1}.",n.Number,n.OddEven);   
       }   
    }  
      
    Repeat  
    public void Linq66() {   
       var numbers = Sequence.Repeat(7,10);   
       foreach (var n in numbers) {   
          Console.WriteLine(n);   
       }   
    }  
      
    Quantifiers  
    Any - Simple  
    public void Linq67() {   
       string[] words = { "believe","relief","receipt","field" };   
       bool iAfterE = words.Any(w => w.Contains("ei"));   
       Console.WriteLine("There is a word that contains in the list that contains 'ei': {0}",iAfterE);   
    }  
      
    Any - Indexed  
    public void Linq68() {   
       int[] numbers = { -9,-4,-8,-3,-5,-2,-1,-6,-7 };   
       bool negativeMatch = numbers.Any((n,index) => n == -index);   
       Console.WriteLine("There is a number that is the negative of its index: {0}",negativeMatch);   
    }  
      
    Any - Grouped  
    public void Linq69() {   
       List products = GetProductList();  
       var productGroups =   
          from p in products   
          group p by p.Category into g   
          where g.Group.Any(p => p.UnitsInStock == 0)   
          select new {Category = g.Key,Products = g.Group};   
       ObjectDumper.Write(productGroups,1);   
    }  
      
    All - Simple  
    public void Linq70() {   
       int[] numbers = { 1,11,19,41,65,19 };  
       bool onlyOdd = numbers.All(n => n % 2 == 1);  
       Console.WriteLine("The list contains only odd numbers: {0}",onlyOdd);   
    }  
      
    All - Indexed  
    public void Linq71() {   
       int[] lowNumbers = { 1,19 };   
       int[] highNumbers = { 7,42,22,45,79,24 };   
       bool allLower = lowNumbers.All((num,index) => num < highNumbers[index]);   
       Console.WriteLine("Each number in the first list is lower than its counterpart in the second list: {0}",allLower);   
    }  
      
    All - Grouped  
    public void Linq72() {   
       List products = GetProductList();  
       var productGroups =   
          from p in products   
          group p by p.Category into g   
          where g.Group.All(p => p.UnitsInStock > 0)   
          select new {Category = g.Key,1);   
    }  
      
    Aggregate Operators  
    Count - Simple  
    public void Linq73() {   
       int[] factorsOf300 = { 2,5 };   
       int uniqueFactors = factorsOf300.Distinct().Count();   
       Console.WriteLine("There are {0} unique factors of 300.",uniqueFactors);   
    }  
      
    Count - Conditional  
    public void Linq74() {   
       int[] numbers = { 5,0 };   
       int oddNumbers = numbers.Count(n => n % 2 == 1);   
       Console.WriteLine("There are {0} odd numbers in the list.",oddNumbers);   
    }  
      
    Count - Indexed  
    public void Linq75() {   
       int[] numbers = { 5,0 };  
       int oddEvenMatches = numbers.Count((n,index) => n % 2 == index % 2);  
       Console.WriteLine("There are {0} numbers in the list whose odd/even status " +   
            "matches that of their position.",oddEvenMatches);   
    }  
      
    Count - Nested  
    public void Linq76() {   
       List customers = GetCustomerList();  
       var orderCounts =   
          from c in customers   
          select new {c.CustomerID,OrderCount = c.Orders.Count()};  
       ObjectDumper.Write(orderCounts);   
    }  
      
    Count - Grouped  
    public void Linq77() {   
       List products = GetProductList();  
       var categoryCounts =   
          from p in products   
          group p by p.Category into g   
          select new {Category = g.Key,ProductCount = g.Group.Count()};  
       ObjectDumper.Write(categoryCounts);   
    }  
      
    Sum - Simple  
    public void Linq78() {   
       int[] numbers = { 5,0 };   
       double numSum = numbers.Sum();   
       Console.WriteLine("The sum of the numbers is {0}.",numSum);   
    }  
      
    Sum - Projection  
    public void Linq79() {  
       string[] words = { "cherry","blueberry" };  
       double totalChars = words.Sum(w => w.Length);  
       Console.WriteLine("There are a total of {0} characters in these words.",totalChars);   
    }  
      
    Sum - Grouped  
    public void Linq80() {   
       List products = GetProductList();  
       var categories =   
          from p in products   
          group p by p.Category into g   
          select new {Category = g.Key,TotalUnitsInStock = g.Group.Sum(p => p.UnitsInStock)};   
       ObjectDumper.Write(categories);   
    }  
      
    Min - Simple  
    public void Linq81() {   
       int[] numbers = { 5,0 };   
       int minNum = numbers.Min();   
       Console.WriteLine("The minimum number is {0}.",minNum);   
    }  
      
    Min - Projection  
    public void Linq82() {   
       string[] words = { "cherry","blueberry" };   
       int shortestWord = words.Min(w => w.Length);   
       Console.WriteLine("The shortest word is {0} characters long.",shortestWord);   
    }  
      
    Min - Grouped  
    public void Linq83() {   
       List products = GetProductList();  
       var categories =   
          from p in products   
          group p by p.Category into g   
          select new {Category = g.Key,CheapestPrice = g.Group.Min(p => p.UnitPrice)};   
       ObjectDumper.Write(categories);   
    }  
      
    Min - Elements  
    public void Linq84() {   
       List products = GetProductList();  
       var categories =   
          from p in products   
          group p by p.Category into g   
          from minPrice = g.Group.Min(p => p.UnitPrice)   
          select new {Category = g.Key,CheapestProducts = g.Group.Where(p => p.UnitPrice == minPrice)};  
       ObjectDumper.Write(categories,1);   
    }  
      
    Max - Simple  
    public void Linq85() {   
       int[] numbers = { 5,0 };  
       int maxNum = numbers.Max();   
       Console.WriteLine("The maximum number is {0}.",maxNum);   
    }  
      
    Max - Projection  
    public void Linq86() {   
       string[] words = { "cherry","blueberry" };   
       int longestLength = words.Max(w => w.Length);   
       Console.WriteLine("The longest word is {0} characters long.",longestLength);   
    }  
      
    Max - Grouped  
    public void Linq87() {   
       List products = GetProductList();  
       var categories =   
          from p in products   
          group p by p.Category into g   
          select new {Category = g.Key,MostExpensivePrice = g.Group.Max(p => p.UnitPrice)};   
       ObjectDumper.Write(categories);   
    }  
      
    Max - Elements  
    public void Linq88() {   
       List products = GetProductList();  
       var categories =   
          from p in products   
          group p by p.Category into g   
          from maxPrice = g.Group.Max(p => p.UnitPrice)   
          select new {Category = g.Key,MostExpensiveProducts = g.Group.Where(p => p.UnitPrice == maxPrice)};   
       ObjectDumper.Write(categories,1);   
    }  
      
    Average - Simple  
    public void Linq89() {   
       int[] numbers = { 5,0 };   
       double averageNum = numbers.Average();   
       Console.WriteLine("The average number is {0}.",averageNum);   
    }  
      
    Average - Projection  
    public void Linq90() {   
       string[] words = { "cherry","blueberry" };   
       double averageLength = words.Average(w => w.Length);   
       Console.WriteLine("The average word length is {0} characters.",averageLength);   
    }  
      
    Average - Grouped  
    public void Linq91() {   
       List products = GetProductList();  
       var categories =   
          from p in products   
          group p by p.Category into g   
          select new {Category = g.Key,AveragePrice = g.Group.Average(p => p.UnitPrice)};   
       ObjectDumper.Write(categories);   
    }  
      
    Fold - Simple  
    public void Linq92() {   
       double[] doubles = { 1.7,2.9 };   
       double product = doubles.Fold((runningProduct,nextFactor) => runningProduct * nextFactor);   
       Console.WriteLine("Total product of all numbers: {0}",product);   
    }  
      
    Fold - Seed  
    public void Linq93() {   
       double startBalance = 100.0;   
       int[] attemptedWithdrawals = { 20,10,40,50,70,30 };   
       double endBalance =   
          attemptedWithdrawals.Fold(startBalance,(balance,nextWithdrawal) =>   
                ( (nextWithdrawal <= balance) ? (balance - nextWithdrawal) : balance ) );   
       Console.WriteLine("Ending balance: {0}",endBalance);   
    }  
      
    Miscellaneous Operators  
    Concat - 1  
    public void Linq94() {  
        int[] numbersA = { 0,8 };  
        var allNumbers = numbersA.Concat(numbersB);  
        Console.WriteLine("All numbers from both arrays:");  
        foreach (var n in allNumbers) {  
            Console.WriteLine(n);  
        }  
    }  
      
    Concat - 2  
    public void Linq95() {  
        List customers = GetCustomerList();  
        List products = GetProductList();  
        var customerNames =  
            from c in customers  
            select c.CompanyName;  
        var productNames =  
            from p in products  
            select p.ProductName;  
        var allNames = customerNames.Concat(productNames);  
        Console.WriteLine("Customer and product names:");  
        foreach (var n in allNames) {  
            Console.WriteLine(n);  
        }  
    }  
      
    EqualAll - 1  
    public void Linq96() {  
        var wordsA = new string[] { "cherry","blueberry" };  
        var wordsB = new string[] { "cherry","blueberry" };  
        bool match = wordsA.EqualAll(wordsB);  
        Console.WriteLine("The sequences match: {0}",match);  
    }  
      
    EqualAll - 2  
    public void Linq97() {  
        var wordsA = new string[] { "cherry","blueberry" };  
        var wordsB = new string[] { "apple","blueberry","cherry" };  
        bool match = wordsA.EqualAll(wordsB);  
        Console.WriteLine("The sequences match: {0}",match);  
    }  
      
    Custom Sequence Operators  
    Combine  
    public static class CustomSequenceOperators  
    {  
        public static IEnumerable Combine(this IEnumerable first,IEnumerable second,Func func) {  
            using (IEnumerator e1 = first.GetEnumerator(),e2 = second.GetEnumerator()) {  
                while (e1.MoveNext() && e2.MoveNext()) {  
                    yield return func(e1.Current,e2.Current);  
                }  
            }  
        }  
    }  
    public void Linq98() {              
        int[] vectorA = { 0,6 };  
        int[] vectorB = { 1,8 };  
        int dotProduct = vectorA.Combine(vectorB,(a,b) => a * b).Sum();  
        Console.WriteLine("Dot product: {0}",dotProduct);  
    }  
      
    Query Execution  
    Deferred  
    public void Linq99() {  
        // Sequence operators form first-class queries that  
        // are not executed until you enumerate over them.  
        int[] numbers = new int[] { 5,0 };  
        int i = 0;  
        var q =  
            from n in numbers  
            select ++i;  
        // Note,the local variable 'i' is not incremented  
        // until each element is evaluated (as a side-effect):  
        foreach (var v in q) {  
            Console.WriteLine("v = {0},i = {1}",v,i);           
        }   
    }  
      
    Immediate  
    public void Linq100() {  
        // Methods like ToList() cause the query to be  
        // executed immediately,caching the results.  
        int[] numbers = new int[] { 5,0 };          
        int i = 0;  
        var q = (  
            from n in numbers  
            select ++i )  
            .ToList();  
        // The local variable i has already been fully  
        // incremented before we iterate the results:  
        foreach (var v in q) {  
            Console.WriteLine("v = {0},i);  
        }   
    }  
      
    Query Reuse  
    public void Linq101() {  
        // Deferred execution lets us define a query once  
        // and then reuse it later after data changes.  
        int[] numbers = new int[] { 5,0 };  
        var lowNumbers =  
            from n in numbers  
            where n <= 3  
            select n;  
        Console.WriteLine("First run numbers <= 3:");  
        foreach (int n in lowNumbers) {  
            Console.WriteLine(n);  
        }  
        for (int i = 0; i < 10; i++) {  
            numbers[i] = -numbers[i];  
        }  
        // During this second run,the same query object,// lowNumbers,will be iterating over the new state  
        // of numbers[],producing different results:  
        Console.WriteLine("Second run numbers <= 3:");  
        foreach (int n in lowNumbers) {  
            Console.WriteLine(n);  
        }  
    }