Linq101-Projection

  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 }