Linq101-Projection

Bertha 。 2021-11-10 12:28 239阅读 0赞

1 using System;
      2 using System.Linq;
      3 
      4 namespace Linq101
      5 {
      6     class Projection
      7     {
      8         /// <summary>
      9         /// This sample uses select to produce a sequence of ints one higher than those in an existing array of ints.
     10         /// </summary>
     11         public void Linq6()
     12         {
     13             int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
     14 
     15             var query = from n in numbers
     16                         select n + 1;
     17 
     18             Console.WriteLine("Numbers + 1 :");
     19             foreach (var i in query)
     20             {
     21                 Console.WriteLine(i);
     22             }
     23         }
     24 
     25         /// <summary>
     26         /// This sample uses select to return a sequence of just the names of a list of products.
     27         /// </summary>
     28         public void Linq7()
     29         {
     30             var products = Data.GetProductList();
     31 
     32             var query = from p in products
     33                         select p.ProductName;
     34 
     35             Console.WriteLine("Product Names:");
     36             foreach (var productName in query)
     37             {
     38                 Console.WriteLine(productName);
     39             }
     40         }
     41 
     42         /// <summary>
     43         /// This sample uses select to produce a sequence of strings representing the text version of a sequence of ints.
     44         /// </summary>
     45         public void Linq8()
     46         {
     47             int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
     48             string[] strings = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
     49 
     50             var query = from n in numbers
     51                         select strings[n];
     52 
     53             Console.WriteLine("Number strings:");
     54             foreach (var s in query)
     55             {
     56                 Console.WriteLine(s);
     57             }
     58         }
     59 
     60         /// <summary>
     61         /// This sample uses select to produce a sequence of the uppercase and lowercase versions of each word in the original array.
     62         /// </summary>
     63         public void Linq9()
     64         {
     65             string[] words = { "aPPLE", "BlUeBeRrY", "cHeRry" };
     66 
     67             var query = from w in words
     68                         select new { U = w.ToUpper(), L = w.ToLower() };
     69 
     70             Console.WriteLine("Results:");
     71             foreach (var item in query)
     72             {
     73                 Console.WriteLine("Uppercase:{0},Lowercase:{1}", item.U, item.L);
     74             }
     75         }
     76 
     77         /// <summary>
     78         /// This sample uses select to produce a sequence containing text representations of digits and whether their length? is even or odd.
     79         /// </summary>
     80         public void Linq10()
     81         {
     82             int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
     83             string[] strings = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
     84 
     85             var query = from n in numbers
     86                         select new { Digit = strings[n], EorO = n % 2 == 0 ? "Even" : "Odd" };
     87 
     88             Console.WriteLine("Results:");
     89             foreach (var item in query)
     90             {
     91                 Console.WriteLine("The digit {0} is {1}", item.Digit, item.EorO);
     92             }
     93         }
     94 
     95         /// <summary>
     96         /// This sample uses select to produce a sequence containing some properties of Products, including UnitPrice which is renamed to Price in the resulting type.
     97         /// </summary>
     98         public void Linq11()
     99         {
    100             var products = Data.GetProductList();
    101 
    102             var query = from p in products
    103                         select new { p.ProductName, p.Category, Price = p.UnitPrice };
    104 
    105             Console.WriteLine("Product Info:");
    106             foreach (var product in query)
    107             {
    108                 Console.WriteLine("{0} is in the category {1} and cost {2} per unit", product.ProductName, product.Category, product.Price);
    109             }
    110         }
    111 
    112         /// <summary>
    113         /// This sample uses an indexed Select clause to determine if the value of ints in an array match their position in the array.
    114         /// </summary>
    115         public void Linq12()
    116         {
    117             int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
    118 
    119             var query = numbers.Select((n, index) => new { Num = n, InPlace = n == index });
    120 
    121             Console.WriteLine("Number:In-place?");
    122             foreach (var number in query)
    123             {
    124                 Console.WriteLine("{0}:{1}", number.Num, number.InPlace);
    125             }
    126         }
    127 
    128         /// <summary>
    129         /// This sample combines select and where to make a simple query that returns the text form of each digit less than 5.
    130         /// </summary>
    131         public void Linq13()
    132         {
    133             int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
    134             string[] digits = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
    135 
    136             var query = from n in numbers
    137                         where n < 5
    138                         select digits[n];
    139 
    140             Console.WriteLine("Numbers < 5:");
    141             foreach (var digit in query)
    142             {
    143                 Console.WriteLine(digit);
    144             }
    145         }
    146 
    147         /// <summary>
    148         /// This sample uses a compound from clause to make a query that returns all pairs of numbers from both arrays such that the number from numbersA is less than the number from numbersB.
    149         /// </summary>
    150         public void Linq14()
    151         {
    152             int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 };
    153             int[] numbersB = { 1, 3, 5, 7, 8 };
    154 
    155             var query = from a in numbersA
    156                         from b in numbersB
    157                         where a < b
    158                         select new { a, b };
    159 
    160             Console.WriteLine("Pairs where a < b");
    161             foreach (var pair in query)
    162             {
    163                 Console.WriteLine("{0} is less than {1}", pair.a, pair.b);
    164             }
    165         }
    166 
    167         /// <summary>
    168         /// This sample uses a compound from clause to select all orders where the order total is less than 500.00.
    169         /// </summary>
    170         public void Linq15()
    171         {
    172             var customers = Data.GetCustomerList();
    173 
    174             var query = from c in customers
    175                         from o in c.Orders
    176                         where o.Total < 500
    177                         select new { c.CustomerID, o.OrderID, o.Total };
    178 
    179             ObjectDumper.Write(query);
    180         }
    181 
    182         /// <summary>
    183         /// This sample uses a compound from clause to select all orders where the order was made in 1998 or later.
    184         /// </summary>
    185         public void Linq16()
    186         {
    187             var customers = Data.GetCustomerList();
    188 
    189             var query = from c in customers
    190                         from o in c.Orders
    191                         where o.OrderDate >= new DateTime(1998, 1, 1)
    192                         select new { c.CustomerID, o.OrderID, o.OrderDate };
    193 
    194             ObjectDumper.Write(query);
    195         }
    196 
    197         /// <summary>
    198         /// This sample uses a compound from clause to select all orders where the order total is greater than 2000.00 and uses from assignment to avoid requesting the total twice.
    199         /// </summary>
    200         public void Linq17()
    201         {
    202             var customers = Data.GetCustomerList();
    203 
    204             var query = from c in customers
    205                         from o in c.Orders
    206                         where o.Total > 2000
    207                         select new { c.CustomerID, o.OrderID, o.Total };
    208 
    209             ObjectDumper.Write(query);
    210         }
    211 
    212         /// <summary>
    213         /// This sample uses multiple from clauses so that filtering on customers can be done before selecting their orders. This makes the query more efficient by not selecting and then discarding orders for customers outside of Washington.
    214         /// </summary>
    215         public void Linq18()
    216         {
    217             var customers = Data.GetCustomerList();
    218 
    219             //效率低
    220             //var query = from c in customers
    221             //            from o in c.Orders
    222             //            where c.Region == "WA" && o.OrderDate >= new DateTime(1997, 1, 1)
    223             //            select new { c.CustomerID, o.OrderID };
    224 
    225             var query = from c in customers
    226                         where c.Region == "WA"
    227                         from o in c.Orders
    228                         where o.OrderDate >= new DateTime(1997, 1, 1)
    229                         select new { c.CustomerID, o.OrderID };
    230 
    231             ObjectDumper.Write(query);
    232         }
    233 
    234         /// <summary>
    235         /// This sample uses an indexed SelectMany clause to select all orders, while referring to customers by the order in which they are returned from the query.
    236         /// </summary>
    237         public void Linq19()
    238         {
    239             var customers = Data.GetCustomerList();
    240 
    241             //var query = customers.SelectMany(c => c.Orders);
    242             //var query = customers.SelectMany(c => c.Orders).Where(o => o.OrderDate >= new DateTime(1998, 1, 1));
    243             var query =
    244                 customers.SelectMany(
    245                     (customer, index) =>
    246                         (customer.Orders.Select(o => "Customer #" + (index + 1) + " has an order with OrderID " + o.OrderID)));
    247 
    248             ObjectDumper.Write(query);
    249         }
    250     }
    251 }

转载于:https://www.cnblogs.com/David-Huang/p/4171171.html