This print for content only-size & color not accurate 7" X 9-1/4" / casebound / malloy

// Build a query expression using extension methods

// granted to the Array via the Enumerable type.

var subset = currentVideoGames.Where(game => game.Length > 6)

.OrderBy(game => game).Select(game => game);

// Print out the results.

foreach (var game in subset)

Console.WriteLine("Item: {0}", game);

Console.WriteLine();

}

Here, we are calling the generic Where() method off the string array object, granted to the Array

type as an extension method defined by Enumerable. The Enumerable.Where() method makes use

of the System.Func delegate type. The first type parameter of this delegate represents

C H A P T E R   1 4  

■

A N   I N T R O D U C T I O N  TO   L I N Q

460

8849CH14.qxd  9/26/07  12:30 PM  Page 460

---

the IEnumerable-compatible data to process (an array of strings in this case), while the second

type parameter represents the method that will process said data.

Given that we have opted for a lambda expression (rather than directly creating an instance

of Func or crafting an anonymous method), we are specifying that the “game” parameter is

processed by the statement game.Length > 6, which results in a Boolean return type.

The return value of the Where() method has implicitly typed, but under the covers we are

operating on an OrderedEnumerable type. From this resulting object, we call the generic OrderBy

K>() method, which also requires a Func delegate parameter. Finally, from the result of the

specified lambda expression, we select each element, using once again a Func under the

covers.

It is also worth remembering that extension methods are unique in that they can be called as

instance-level members upon the type they are extending (System.Array in this case) or as static

members using the type they were defined within. Given this, we could also author our query

expression as follows:

var subset = Enumerable.Where(currentVideoGames, game => game.Length > 6)

.OrderBy(game => game).Select(game => game);

As you may agree, building a LINQ query expression using the methods of the Enumerable type

directly is much more verbose than making use of the C# query operators. As well, given that the

methods of Enumerable require delegates as parameters, you will typically need to author lambda

expressions to allow the input data to be processed by the underlying delegate target.