The syntax of LINQ is built into C#, but LINQ queries may be used in many different contexts because of libraries known as providers. A LINQ provider is a set of classes that implement LINQ operations and enable programs to interact with data sources to perform tasks such as sorting, grouping and filtering elements.

In this book, we discuss LINQ to SQL and LINQ to XML, which allow you to query databases and XML documents using LINQ. These providers, along with LINQ to Objects, mentioned above, are included with Visual Studio and the .NET Framework. There are many providers that are more specialized, allowing you to interact with a specific website or data format. An extensive list of available providers is located at:

blogs.msdn.com/charlie/archive/2006/10/05/Links-to-LINQ.aspx

A LINQ query begins with a from clause (line 20), which specifies a range variable (value) and the data source to query (values). The range variable represents each item in the data source (one at a time), much like the control variable in a foreach statement. We do not specify the range variable’s type. Since it is assigned one element at a time from the array values, which is an int array, the compiler determines that the range variable value should be of type int. This is a C# feature called implicitly typed local variables, which enables the compiler to infer a local variable’s type based on the context in which it’s used.

Introducing the range variable in the from clause at the beginning of the query allows the IDE to provide IntelliSense while you write the rest of the query. The IDE knows the range variable’s type, so when you enter the range variable’s name followed by a dot (.) in the code editor, the IDE can display the range variable’s methods and properties.

You can also declare a local variable and let the compiler infer the variable’s type based on the variable’s initializer. To do so, the var keyword is used in place of the variable’s type when declaring the variable. Consider the declaration

var x = 7;

Here, the compiler infers that the variable x should be of type int, because the compiler assumes that whole-number values, like 7, are of type int. Similarly, in the declaration

var y = -123.45;

the compiler infers that y should be of type double, because the compiler assumes that floating-point number values, like -123.45, are of type double. Typically, implicitly typed local variables are used for more complex types, such as the collections of data returned by LINQ queries. We use this feature in lines 19, 30, 41 and 53 to enable the compiler to determine the type of each variable that stores the results of a LINQ query. We also use this feature to declare the control variable in the foreach statements at lines 15–16, 26–27, 37–38, 49–50 and 62–63. In each case, the compiler infers that the control variable is of type int because the array values and the LINQ query results all contain int values.

If the condition in the where clause (line 21) evaluates to true, the element is selected—i.e., it’s included in the results. Here, the ints in the array are included only if they’re greater than 4. An expression that takes an element of a collection and returns true or false by testing a condition on that element is known as a predicate.

For each item in the data source, the select clause (line 22) determines what value appears in the results. In this case, it’s the int that the range variable currently represents. A LINQ query typically ends with a select clause.

Lines 26–27 use a foreach statement to display the query results. As you know, a foreach statement can iterate through the contents of an array, allowing you to process each element in the array. Actually, the foreach statement can iterate through the contents arrays, collections and the results of LINQ queries. The foreach statement in lines 26–27 iterates over the query result filtered, displaying each of its items.

It would be simple to display the integers greater than 4 using a repetition statement that tests each value before displaying it. However, this would intertwine the code that selects elements and the code that displays them. With LINQ, these are kept separate, making the code easier to understand and maintain.

The orderby clause (line 32) sorts the query results in ascending order. Lines 43 and 56 use the descending modifier in the orderby clause to sort the results in descending order. An ascending modifier also exists but isn’t normally used, because it’s the default. Any value that can be compared with other values of the same type may be used with the orderby clause. A value of a simple type (e.g., int) can always be compared to another value of the same type; we’ll say more about comparing values of reference types in Chapter 12.

The queries in lines 42–44 and 54–57 generate the same results, but in different ways. The first query uses LINQ to sort the results of the query from lines 20–22. The second query uses both the where and orderby clauses. Because queries can operate on the results of other queries, it’s possible to build a query one step at a time, and pass the results of queries between methods for further processing.

Implicitly typed local variables can also be used to initialize arrays without explicitly giving their type. For example, the following statement creates an array of int values:

var array = new[] { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };

Note that there are no square brackets on the left side of the assignment operator, and that new[] is used to specify that the variable is an array.

As we mentioned, the foreach statement can iterate through the contents of arrays, collections and LINQ query results. Actually, foreach iterates over any so-called IEnumerable<T> object, which just happens to be what a LINQ query returns.

IEnumerable<T> is an interface. Interfaces define and standardize the ways in which people and systems can interact with one another. For example, the controls on a radio serve as an interface between radio users and the radio’s internal components. The controls allow users to perform a limited set of operations (e.g., changing the station, adjusting the volume, and choosing between AM and FM), and different radios may implement the controls in different ways (e.g., using push buttons, dials or voice commands). The interface specifies what operations a radio permits users to perform but does not specify how the operations are implemented. Similarly, the interface between a driver and a car with a manual transmission includes the steering wheel, the gear shift, the clutch, the gas pedal and the brake pedal. This same interface is found in nearly all manual-transmission cars, enabling someone who knows how to drive one manual-transmission car to drive another.

Software objects also communicate via interfaces. A C# interface describes a set of methods that can be called on an object—to tell the object, for example, to perform some task or return some piece of information. The IEnumerable<T> interface describes the functionality of any object that can be iterated over and thus offers methods to access each element. A class that implements an interface must define each method in the interface with a signature identical to the one in the interface definition. Implementing an interface is like signing a contract with the compiler that states, “I will declare all the methods specified by the interface.” Chapter 12 covers use of interfaces in more detail, as well as how to define your own interfaces.

Arrays are IEnumerable<T> objects, so a foreach statement can iterate over an array’s elements. Similarly, each LINQ query returns an IEnumerable<T> object. Therefore, you can use a foreach statement to iterate over the results of any LINQ query. The notation <T> indicates that the interface is a generic interface that can be used with any type of data (for example, ints, strings or Employees). You’ll learn more about the <T> notation in Section 9.4. You’ll learn more about interfaces in Section 12.7.

Line 28 of Fig. 9.4 shows a where clause that accesses the properties of the range variable. In this example, the compiler infers that the range variable is of type Employee based on its knowledge that employees was defined as an array of Employee objects (lines 11–18). Any bool expression can be used in a where clause. Line 28 uses the conditional AND (&&) operator to combine conditions. Here, only employees that have a salary between $4,000 and $6,000 per month, inclusive, are included in the query result, which is displayed in lines 35–36.

Line 41 uses an orderby clause to sort the results according to multiple properties—specified in a comma-separated list. In this query, the employees are sorted alphabetically by last name. Each group of Employees that have the same last name is then sorted within the group by first name.

Line 48 introduces the query result’s Any method, which returns true if there’s at least one element, and false if there are no elements. The query result’s First method (line 49) returns the first element in the result. You should check that the query result is not empty (line 48) before calling First.

We’ve not specified the class that defines methods First and Any. Your intuition probably tells you they’re methods declared in the IEnumerable<T> interface, but they aren’t. They’re actually extension methods, but they can be used as if they were methods of IEnumerable<T>.

LINQ defines many more extension methods, such as Count, which returns the number of elements in the results. Rather than using Any, we could have checked that Count was nonzero, but it’s more efficient to determine whether there’s at least one element than to count all the elements. The LINQ query syntax is actually transformed by the compiler into extension method calls, with the results of one method call used in the next. It’s this design that allows queries to be run on the results of previous queries, as it simply involves passing the result of a method call to another method.

Line 56 uses the select clause to select the range variable’s LastName property rather than the range variable itself. This causes the results of the query to consist of only the last names (as strings), instead of complete Employee objects. Lines 60–61 display the unique last names. The Distinct extension method (line 60) removes duplicate elements, causing all elements in the result to be unique.

The last LINQ query in the example (lines 65–66) selects the properties FirstName and LastName. The syntax

new { e.FirstName, Last = e.LastName }

creates a new object of an anonymous type (a type with no name), which the compiler generates for you based on the properties listed in the curly braces ({}). In this case, the anonymous type consists of properties for the first and last names of the selected Employee. The LastName property is assigned to the property Last in the select clause. This shows how you can specify a new name for the selected property. If you don’t specify a new name, the property’s original name is used—this is the case for FirstName in this example. The preceding query is an example of a projection—it performs a transformation on the data. In this case, the transformation creates new objects containing only the FirstName and Last properties. Transformations can also manipulate the data. For example, you could give all employees a 10% raise by multiplying their MonthlySalary properties by 1.1.

When creating a new anonymous type, you can select any number of properties by specifying them in a comma-separated list within the curly braces ({}) that delineate the anonymous type definition. In this example, the compiler automatically creates a new class having properties FirstName and Last, and the values are copied from the Employee objects. These selected properties can then be accessed when iterating over the results. Implicitly typed local variables allow you to use anonymous types because you do not have to explicitly state the type when declaring such variables.

When the compiler creates an anonymous type, it automatically generates a ToString method that returns a string representation of the object. You can see this in the program’s output—it consists of the property names and their values, enclosed in braces. Anonymous types are discussed in more detail in Chapter 18.