The program starts by creating a customer list with some sample data, taking advantage of object initialization as discussed in Chapter 4. Once the list of customers is created, Example 13-1 defines a LINQ query:

IEnumerable<Customer> result =
                from   customer in customers
                where  customer.FirstName == "Donna"
                select customer;

The result variable is initialized with a query expression. In this example, the query will retrieve all Customer objects whose first name is “Donna” from the customer list. The result of such a query is a collection that implements IEnumerable<T>, where T is the type of the result object. In this example, because the query result is a set of Customer objects, the type of the result variable is IEnumerable<Customer>.

Let’s dissect the query and look at each part in more detail.

from   customer in customers

where  customer.FirstName == "Donna"

where  customer.LastName.StartsWith("G")

select customer;

  select customer.EmailAddress;

LINQ implements deferred query evaluation, meaning that the declaration and initialization of a query expression do not actually execute the query. Instead, a LINQ query is executed, or evaluated, when you iterate through the query result:

foreach (Customer customer in result)
    Console.WriteLine(customer.ToString(  ));

Because the query returns a collection of Customer objects, the iteration variable is an instance of the Customer class. You can use it as you would any Customer object. This example simply calls each Customer object’s ToString( ) method to output its property values to the console.

Each time you iterate through this foreach loop, the query will be reevaluated. If the data source has changed between executions, the result will be different. This is demonstrated in the next code section:

customers[3].FirstName = "Donna";

Here, you modify the first name of the customer “Janet Gates” to “Donna” and then iterate through the result again:

Console.WriteLine("FirstName == "Donna" (take two)");
foreach (Customer customer in result)
    Console.WriteLine(customer.ToString(  ));

As shown in the sample output, you can see that the result now includes Donna Gates as well.

In most situations, deferred query evaluation is desired because you want to obtain the most recent data in the data source each time you run the query. However, if you want to cache the result so that it can be processed later without having to reexecute the query, you can call either the ToList( ) or the ToArray( ) method to save a copy of the result. Example 13-2 demonstrates this technique as well.

using System;
using System.Collections.Generic;
using System.Linq;
namespace Programming_CSharp
{
    // Simple customer class
    public class Customer
    {
        // Same as in Example 13-1
    }

    // Main program
    public class Tester
    {
        static void Main(  )
        {
            List<Customer> customers = CreateCustomerList(  );

            // Find customer by first name
            IEnumerable<Customer> result =
                from customer in customers
                where customer.FirstName == "Donna"
                select customer;
            List<Customer> cachedResult = result.ToList<Customer>(  );

            Console.WriteLine("FirstName == "Donna"");
            foreach (Customer customer in cachedResult)
                Console.WriteLine(customer.ToString(  ));

            customers[3].FirstName = "Donna";
            Console.WriteLine("FirstName == "Donna" (take two)");
            foreach (Customer customer in cachedResult)
                Console.WriteLine(customer.ToString(  ));
        }

        // Create a customer list with sample data
        private static List<Customer> CreateCustomerList(  )
        {
            // Same as in Example 13-1
        }
    }
}

Output:
FirstName == "Donna"
Donna Carreras
Email:   [email protected]
FirstName == "Donna" (take two)
Donna Carreras
Email:   [email protected]

In this example, you call the ToList<T> method of the result collection to cache the result. Note that calling this method causes the query to be evaluated immediately. If the data source is changed after this, the change will not be reflected in the cached result. You can see from the output that there is no Donna Gates in the result.

One interesting point here is that the ToList<T> and ToArray<T> methods are not actually methods of IEnumerable; that is, if you look in the documentation for IEnumerable, you will not see them in the methods list. They are actually extension methods provided by LINQ. We will look at extension methods in more detail later in this chapter.

If you are familiar with SQL, you will notice a striking similarity between LINQ and SQL, at least in their syntax. The only odd-one-out at this stage is that the select statement in LINQ appears at the end of LINQ query expressions, instead of at the beginning, as in SQL. Because the generator, or the from clause, defines the range variable, it must be stated first. Therefore, the projection part is pushed back.

You will often want to search for objects from more than one data source. LINQ provides the join clause that offers the ability to join many data sources, not all of which need be databases. Suppose you have a list of customers containing customer names and email addresses, and a list of customer home addresses. You can use LINQ to combine both lists to produce a list of customers, with access to both their email and home addresses:

    from customer in customers
         join address in addresses on
              customer.Name equals address.Name
    ...

The join condition is specified in the on subclause, similar to SQL, except that the objects joined need not be tables or views in a database. The join class syntax is:

 [data source 1] join [data source 2] on [join condition]

Here, we are joining two data sources, customers and addresses, based on the customer name properties in each object. In fact, you can join more than two data sources using a combination of join clauses:

from customer in customers
    join address in addresses on
        customer.Name equals address.Name
    join invoice in invoices  on
        customer.Id   equals invoice.CustomerId
    join invoiceItem in invoiceItems on
        invoice.Id    equals invoiceItem.invoiceId

A LINQ join clause returns a result only when objects satisfying the join condition exist in all data sources. For instance, if a customer has no invoice, the query will not return anything for that customer, not even her name and email address. This is the equivalent of a SQL inner join clause.

You can also specify the sort order in LINQ queries with the orderby clause:

from customer in Customers
    orderby customer.LastName
    select customer;

This sorts the result by customer last name in ascending order. Example 13-3 shows how you can sort the results of a join query.

using System;
using System.Collections.Generic;
using System.Linq;

namespace Programming_CSharp
{
    // Simple customer class
    public class Customer
    {
        // Same as in Example 13-1
    }

    // Customer address class
    public class Address
    {
        public string Name   { get; set; }
        public string Street { get; set; }
        public string City   { get; set; }

        // Overrides the Object.ToString(  ) to provide a
        // string representation of the object properties.
        public override string ToString(  )
        {
            return string.Format("{0}, {1}", Street, City);
        }
    }

    // Main program
    public class Tester
    {
        static void Main(  )
        {
            List<Customer> customers = CreateCustomerList(  );
            List<Address>  addresses = CreateAddressList(  );

            // Find all addresses of a customer
            var result =
                from customer in customers
                join address in addresses on
                     string.Format("{0} {1}", customer.FirstName,
                         customer.LastName)
                     equals address.Name
                orderby customer.LastName, address.Street descending
                select new { Customer = customer, Address = address };

            foreach (var ca in result)
            {
                Console.WriteLine(string.Format("{0}
Address: {1}",
                    ca.Customer, ca.Address));
            }
        }

        // Create a customer list with sample data
        private static List<Customer> CreateCustomerList(  )
        {
            // Same as in Example 13-1
        }

        // Create a customer list with sample data
        private static List<Address> CreateAddressList(  )
        {
            List<Address> addresses = new List<Address>
                {
                    new Address { Name   = "Janet Gates",
                                  Street = "165 North Main",
                                    City = "Austin" },
                    new Address { Name   = "Keith Harris",
                                  Street = "3207 S Grady Way",
                                    City = "Renton" },
                    new Address { Name   = "Janet Gates",
                                  Street = "800 Interchange Blvd.",
                                    City = "Austin" },
                    new Address { Name   = "Keith Harris",
                                  Street = "7943 Walnut Ave",
                                    City = "Renton" },
                    new Address { Name   = "Orlando Gee",
                                  Street = "2251 Elliot Avenue",
                                    City = "Seattle" }
                };
            return addresses;
        }
    }
}

Output:
Janet Gates
Email:   [email protected]
Address: 800 Interchange Blvd., Austin
Janet Gates
Email:   [email protected]
Address: 165 North Main, Austin
Orlando Gee
Email:   [email protected]
Address: 2251 Elliot Avenue, Seattle
Keith Harris
Email:   [email protected]
Address: 7943 Walnut Ave, Renton
Keith Harris
Email:   [email protected]
Address: 3207 S Grady Way, Renton

The Customer class is identical to the one used in Example 13-1. The address is also very simple, with a customer name field containing customer names in the <first name> <last name> form, and the street and city of customer addresses.

The CreateCustomerList( ) and CreateAddressList( ) methods are just helper functions to create sample data for this example. This example also uses the new C# object and collection initializers, as explained in Chapter 4.

The query definition, however, looks quite different from the last example:

var result =
    from   customer in customers
           join address in addresses on
                string.Format("{0} {1}", customer.FirstName, customer.LastName)
                equals address.Name
    orderby customer.LastName, address.Street descending
    select new { Customer = customer, Address = address.Street };

The first difference is the declaration of the result. Instead of declaring the result as an explicitly typed IEnumerable<Customer> instance, this example declares the result as an implicitly typed variable using the new var keyword. We will leave this for just a moment, and jump to the query definition itself.

The generator now contains a join clause to signify that the query is to be operated on two data sources: customers and addresses. Because the customer name property in the Address class is a concatenation of customer first and last names, you construct the names in Customer objects to the same format:

string.Format("{0} {1}", customer.FirstName, customer.LastName)

The dynamically constructed customer full name is then compared with the customer name property in the Address objects using the equals operator:

string.Format("{0} {1}", customer.FirstName, customer.LastName)
equals address.Name

The orderby clause indicates the order in which the result should be sorted:

    orderby customer.LastName, address.Street descending

In the example, the result will be sorted first by customer last name in ascending order, then by street address in descending order.

The combined customer name, email address, and home address are returned. Here you have a problem—LINQ can return a collection of objects of any type, but it can’t return multiple objects of different types in the same query, unless they are encapsulated in one type. For instance, you can select either an instance of the Customer class or an instance of the Address class, but you cannot select both, like this:

    select customer, address

The solution is to define a new type containing both objects. An obvious way is to define a CustomerAddress class:

    public class CustomerAddress
    {
        public Customer Customer { get; set; }
        public Address Address   { get; set; }
    }

You can then return customers and their addresses from the query in a collection of CustomerAddress objects:

var result =
    from   customer in customers
           join address in addresses on
                string.Format("{0} {1}", customer.FirstName, customer.LastName)
                equals address.Name
    orderby customer.LastName, address.Street descending
    Select new CustomerAddress { Customer = customer, Address = address };

Another powerful feature of LINQ, commonly used by SQL programmers but now integrated into the language itself, is grouping, as shown in Example 13-4.

using System;
using System.Collections.Generic;
using System.Linq;

namespace Programming_CSharp
{
    // Customer address class
    public class Address
    {
        // Same as in Example 13-3
    }

    // Main program
    public class Tester
    {
        static void Main(  )
        {
            List<Address>  addresses = CreateAddressList(  );// Find addresses grouped by customer name
            var result =
                from address in addresses
                group address by address.Name;
            foreach (var group in result)
            {
                Console.WriteLine("{0}", group.Key);
                foreach (var a in group)
                    Console.WriteLine("	{0}", a);
            }
                     }

        // Create a customer list with sample data
        private static List<Address> CreateAddressList(  )
        {
        // Same as in Example 13-3
        }
    }
}

Output:
Janet Gates
        165 North Main, Austin
        800 Interchange Blvd., Austin
Keith Harris
        3207 S Grady Way, Renton
        7943 Walnut Ave, Renton
Orlando Gee
        2251 Elliot Avenue, Seattle

Example 13-4 makes use of the group keyword, a query operator that splits a sequence into a group given a key value—in this case, customer name (address.Name). The result is a collection of groups, and you’ll need to enumerate each group to get the objects belonging to it.

C# 3.0 introduces extension methods that provide the ability for programmers to add methods to existing types. For instance, System.String does not provide a Right( ) function that returns the rightmost n characters of a string. If you use this functionality a lot in your application, you may have considered building and adding it to your library. However, System.String is defined as sealed, so you can’t subclass it. It is not a partial class, so you can’t extend it using that feature.

Of course, you can’t modify the .NET core library directly either. Therefore, you would have to define your own helper method outside of System.String and call it with syntax such as this:

MyHelperClass.GetRight(aString, n)

This is not exactly intuitive. With C# 3.0, however, there is a more elegant solution. You can actually add a method to the System.String class; in other words, you can extend the System.String class without having to modify the class itself. Such a method is called an extension method. Example 13-6 demonstrates how to define and use an extension method.

using System;

namespace Programming_CSharp_Extensions
{
    // Container class for extension methods.
    public static class ExtensionMethods
    {
        // Returns a substring containing the rightmost
        // n characters in a specific string.
        public static string Right(this string s, int n)
        {
            if (n < 0 || n > s.Length)
                return s;
            else
                return s.Substring(s.Length - n);
        }
    }

    public class Tester
    {
        public static void Main(  )
        {
            string hello = "Hello";
            Console.WriteLine("hello.Right(−1) = {0}", hello.Right(−1));
            Console.WriteLine("hello.Right(0) = {0}", hello.Right(0));
            Console.WriteLine("hello.Right(3) = {0}", hello.Right(3));
            Console.WriteLine("hello.Right(5) = {0}", hello.Right(5));
            Console.WriteLine("hello.Right(6) = {0}", hello.Right(6));
        }
    }
}

Output:
hello.Right(−1) = Hello
hello.Right(0) =
hello.Right(3) = llo
hello.Right(5) = Hello
hello.Right(6) = Hello

The first parameter of an extension method is always the target type, which is the string class in this example. Therefore, this example effectively defines a Right( ) function for the string class. You want to be able to call this method on any string, just like calling a normal System.String member method:

aString.Right(n)

In C#, an extension method must be defined as a static method in a static class. Therefore, this example defines a static class, ExtensionMethods, and a static method in this class:

public static string Right(this string s, int n)
{
    if (n < 0 || n > s.Length)
        return s;
    else
        return s.Substring(s.Length - n);
}

Compared to a regular method, the only notable difference is that the first parameter of an extension method always consists of the this keyword, followed by the target type, and finally an instance of the target type:

this string s

The subsequent parameters are just normal parameters of the extension method. The method body has no special treatment compared to regular methods either. Here, this function simply returns the desired substring or, if the length argument n is invalid, the original string.

To use an extension method, it must be in the same scope as the client code. If the extension method is defined in another namespace, you should add a “using” directive to import the namespace where the extension method is defined. You can’t use fully qualified extension method names as you do with a normal method. The use of extension methods is otherwise identical to any built-in methods of the target type. In this example, you simply call it like a regular System.String method:

hello.Right(3)

It is worth mentioning, however, that extension methods are somewhat more restrictive than regular member methods—extension methods can only access public members of target types. This prevents the breach of encapsulation of the target types.

Another restriction is that if an extension method conflicts with a member method in the target class, the member method is always used instead of the extension method, as you can see in Example 13-7.

using System;

namespace Programming_CSharp_Extensions
{
    // Container class for extension methods.
    public static class ExtensionMethods
    {
        // Returns a substring between the specific
        // start and end index of a string.
        public static string Substring(this string s, int startIndex, int endIndex)
        {
            if (startIndex >= 0 && startIndex <= endIndex && endIndex < s.Length)
                return s.Substring(startIndex, endIndex - startIndex);
            else
                return s;
        }
    }

    public class Tester
    {
        public static void Main(  )
        {
            string hello = "Hello";
            Console.WriteLine("hello.Substring(2, 3) = {0}",
                              hello.Substring(2, 3));
        }
    }
}

Output:
hello.Substring(2, 3) = llo

The Substring( ) extension method in this example has exactly the same signature as the built-in String.Substring(int startIndex, int length) method. As you can see from the output, it is the built-in Substring( ) method that is executed in this example. Now, we’ll go back to Example 13-4, where we used the LINQ extension method, Where, to search a customer list:

IEnumerable<Customer> result =
    customers.Where(customer => customer.FirstName == "Donna");

This method takes a predicate as an input argument.

The predicate performs a filtering operation on queries. The argument to this method is quite different from a normal method argument. In fact, it’s a lambda expression, which I introduced in Chapter 12.