101个LINQ例子

101 LINQ Samples

转自MSDN

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, 4, 1, 3, 9, 8, 6, 7, 2, 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, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
    string[] strings = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "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, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
    string[] strings = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "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, 4, 1, 3, 9, 8, 6, 7, 2, 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, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
    string[] digits = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "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, 2, 4, 5, 6, 8, 9 };
    int[] numbersB = { 1, 3, 5, 7, 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, 1)
        select new {c.CustomerID, o.OrderID, 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, o.OrderID, total};
    ObjectDumper.Write(orders);
}
SelectMany - Multiple from
public void Linq18() {
    List customers = GetCustomerList();
    DateTime cutoffDate = new DateTime(1997, 1, 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, 4, 1, 3, 9, 8, 6, 7, 2, 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.OrderID, 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, 4, 1, 3, 9, 8, 6, 7, 2, 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.OrderID, 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, 4, 1, 3, 9, 8, 6, 7, 2, 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, 4, 1, 3, 9, 8, 6, 7, 2, 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, 4, 1, 3, 9, 8, 6, 7, 2, 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", "apple", "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", "BlUeBeRrY", "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, y, true);    }}publicvoid Linq34() {    string[] words = { "aPPLE", "AbAcUs", "bRaNcH", "BlUeBeRrY", "ClOvEr", "cHeRry"};        var sortedWords = words.OrderByDescending(a => a, new CaseInsensitiveComparer());            ObjectDumper.Write(sortedWords);}

ThenBy - Simple

publicvoid Linq35() {    string[] digits = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "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, string y)    {        returnstring.Compare(x, y, true);    }}publicvoid Linq36() {    string[] words = { "aPPLE", "AbAcUs", "bRaNcH", "BlUeBeRrY", "ClOvEr", "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, string y)    {        returnstring.Compare(x, y, true);    }}publicvoid Linq38() {    string[] words = { "aPPLE", "AbAcUs", "bRaNcH", "BlUeBeRrY", "ClOvEr", "cHeRry"};        var sortedWords =        words.OrderBy(a => a.Length)                .ThenByDescending(a => a, new CaseInsensitiveComparer());            ObjectDumper.Write(sortedWords);}

Reverse

publicvoid Linq39() {    string[] digits = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "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, 4, 1, 3, 9, 8, 6, 7, 2, 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", "apple", "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 ", " salt", " earn ", " last ", " near ", " 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, 2, 3, 5, 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, 2, 4, 5, 6, 8, 9 };    int[] numbersB = { 1, 3, 5, 7, 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, 2, 4, 5, 6, 8, 9 };    int[] numbersB = { 1, 3, 5, 7, 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, 2, 4, 5, 6, 8, 9 }; int[] numbersB = { 1, 3, 5, 7, 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.3, 1.9, 4.1, 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", "apple", "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, "two", 3, 4.0f, 5, "six", 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, 4, 1, 3, 9, 8, 6, 7, 2, 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.3, 4.1, 1.9, 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, 4, 1, 3, 9, 8, 6, 7, 2, 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, 3, 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, 11, 3, 19, 41, 65, 19 }; int[] highNumbers = { 7, 19, 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, Products = g.Group}; ObjectDumper.Write(productGroups, 1); }

Aggregate Operators

Count - Simple
public void Linq73() { int[] factorsOf300 = { 2, 2, 3, 5, 5 }; int uniqueFactors = factorsOf300.Distinct().Count(); Console.WriteLine("There are {0} unique factors of 300.", uniqueFactors); }
Count - Conditional
public void Linq74() { int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 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, 4, 1, 3, 9, 8, 6, 7, 2, 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, 4, 1, 3, 9, 8, 6, 7, 2, 0 }; double numSum = numbers.Sum(); Console.WriteLine("The sum of the numbers is {0}.", numSum); }
Sum - Projection
public void Linq79() { string[] words = { "cherry", "apple", "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, 4, 1, 3, 9, 8, 6, 7, 2, 0 }; int minNum = numbers.Min(); Console.WriteLine("The minimum number is {0}.", minNum); }
Min - Projection
public void Linq82() { string[] words = { "cherry", "apple", "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, 4, 1, 3, 9, 8, 6, 7, 2, 0 }; int maxNum = numbers.Max(); Console.WriteLine("The maximum number is {0}.", maxNum); }
Max - Projection
public void Linq86() { string[] words = { "cherry", "apple", "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, 4, 1, 3, 9, 8, 6, 7, 2, 0 }; double averageNum = numbers.Average(); Console.WriteLine("The average number is {0}.", averageNum); }
Average - Projection
public void Linq90() { string[] words = { "cherry", "apple", "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.3, 1.9, 4.1, 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, 10, 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, 2, 4, 5, 6, 8, 9 }; int[] numbersB = { 1, 3, 5, 7, 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", "apple", "blueberry" }; var wordsB = new string[] { "cherry", "apple", "blueberry" }; bool match = wordsA.EqualAll(wordsB); Console.WriteLine("The sequences match: {0}", match); }
EqualAll - 2
public void Linq97() { var wordsA = new string[] { "cherry", "apple", "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, 2, 4, 5, 6 }; int[] vectorB = { 1, 3, 5, 7, 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, 4, 1, 3, 9, 8, 6, 7, 2, 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, 4, 1, 3, 9, 8, 6, 7, 2, 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 = {1}", v, 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, 4, 1, 3, 9, 8, 6, 7, 2, 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); } }

101个LINQ例子

101 LINQ Samples

Restriction Operators

Projection Operators

Partitioning Operators

Ordering Operators

Grouping Operators

Set Operators

Conversion Operators

Element Operators

Generation Operators

Quantifiers

Aggregate Operators

Miscellaneous Operators

Custom Sequence Operators

Query Execution

你可能感兴趣的:(LINQ)