ASP.NET

A Few More Simple Queries

var Found = from o in Orders
          where o.CustomerID == 84
          select new { OrderID = o.OrderID, Cost = o.Cost };

var Found = from o in Orders
          where o.CustomerID == 84
          select new { o.OrderID, o.Cost };

var Found = from o in Orders
          where o.CustomerID == 84
          select new {
                     o.OrderID,
                     o.Cost,
                     CostWithTax = o.Cost * 1.1
                 };

var Found = from o in Orders
          where o.CustomerID == 84 && o.Cost > 100
          select new {
                     o.OrderID,
                     o.Cost,
                     CostWithTax = o.Cost * 1.1
                 };

Ordering

var Found = from o in Orders
          where o.CustomerID == 84
          orderby o.Cost ascending
          select new { o.OrderID, o.Cost };

Random R = new Random();
var Found = from o in Orders
          where o.CustomerID == 84
          orderby R.Next()
          select new { OrderID = o.OrderID, Cost = o.Cost };

Joins

class Customer
{
  private int _CustomerID;
  private string _Name;
  private string _Email;
  public int CustomerID
  {
      get { return _CustomerID; }
      set { _CustomerID = value; }
  }
  public string Name
  {
      get { return _Name; }
      set { _Name = value; }
  }
  public string Email
  {
      get { return _Email; }
      set { _Email = value; }
  }
}

var Customers = new List {
                  new Customer {
                      CustomerID = 7,
                      Name = "Emma",
                      Email = "emz0r@worreva.com"
                  },
                  new Customer {
                      CustomerID = 84,
                      Name = "Pedro",
                      Email = "pedro@cerveza.es"
                  },
                  new Customer {
                      CustomerID = 102,
                      Name = "Vladimir",
                      Email = "vladimir@pivo.ru"
                  }
              };

// Query.
var Found = from o in Orders
          join c in Customers on o.CustomerID equals c.CustomerID
          select new { c.Name, o.OrderID, o.Cost };
// Display results.
foreach (var Result in Found)
  Console.WriteLine(Result.Name + " spent " +
      Result.Cost.ToString() + " in order " +
      Result.OrderID.ToString());

Pedro spent 159.12 in order 1
Emma spent 18.5 in order 2
Pedro spent 2.89 in order 3

Pedro spent 159.12 in order 1
Vladimir spent 159.12 in order 1
Emma spent 18.5 in order 2
Pedro spent 2.89 in order 3
Vladimir spent 2.89 in order 3

Getting All Permutations With Multiple "from"s

var Found = from o in Orders
          from c in Customers
          select new { c.Name, o.OrderID, o.Cost };

Emma spent 159.12 in order 1
Pedro spent 159.12 in order 1
Vladimir spent 159.12 in order 1
Emma spent 18.5 in order 2
Pedro spent 18.5 in order 2
Vladimir spent 18.5 in order 2
Emma spent 2.89 in order 3
Pedro spent 2.89 in order 3
Vladimir spent 2.89 in order 3

var Found = from o in Orders
          from c in Customers
          where o.CustomerID == c.CustomerID
          select new { c.Name, o.OrderID, o.Cost };

Grouping

// Group orders by customer.
var OrdersByCustomer = from o in Orders
                     group o by o.CustomerID;
// Iterate over the groups.
foreach (var Cust in OrdersByCustomer)
{
  // About the customer...
  Console.WriteLine("Customer with ID " + Cust.Key.ToString() +
      " ordered " + Cust.Count().ToString() + " items.");
  // And what they ordered.
  foreach (var Item in Cust)
      Console.WriteLine("    ID: " + Item.OrderID.ToString() +
          " Cost: " + Item.Cost.ToString());
}

Customer with ID 84 ordered 2 items.
  ID: 1 Cost: 159.12
  ID: 3 Cost: 2.89
Customer with ID 7 ordered 1 items.
  ID: 2 Cost: 18.5

// Group orders by customer.
var OrdersByCustomer = from o in Orders
                     group o.Cost by o.CustomerID;
// Iterate over the groups.
foreach (var Cust in OrdersByCustomer)
{
  // About the customer...
  Console.WriteLine("Customer with ID " + Cust.Key.ToString() +
      " ordered " + Cust.Count().ToString() + " items.");
  // And the costs of what they ordered.
  foreach (var Cost in Cust)
      Console.WriteLine("    Cost: " + Cost.ToString());
}

Customer with ID 84 ordered 2 items.
  Cost: 159.12
  Cost: 2.89
Customer with ID 7 ordered 1 items.
  Cost: 18.5

Query Continuations

var CheapOrders = from o in Orders
                where o.Cost <>Then it will lead to a compilation error. Since both "select" and "group ... by ..." terminate a query, you need a way of taking the results and using them as the input to another query. This is called a query continuation, and the keyword for this is "into".

In the following example we take the result of grouping orders by customer and then use a select to return an anonymous type containing the CustomerID and the number of orders that the customer has placed. 
var OrderCounts = from o in Orders
                group o by o.CustomerID into g
                select new {
                           CustomerID = g.Key,
                           TotalOrders = g.Count()
                       };
Notice the identifier "g", which we introduce after the keyword "into". This identifier represents an item in the collection containing the results of the previous query. We use in the select statement. Remember that each element of the collection we are querying in this second query is actually a collection itself, since this is what "group ... by ..." produces. Therefore, we can call Count() on it to get the number of elements, which is the number of orders per customer. We grouped by the CustomerID field, so that is our Key.

Query continuations can be used to chain together as many selection and grouping queries as you need in whatever order you need.

Under The Hood 
 Now we have looked at the practicalities of using Linq, I am going to spend a little time taking a look at how it works. Don't worry if you don't understand everything in this section, it's here for those who like to dig a little deeper.

Throughout the series I have talked about how all of the language features introduced in C# 3.0 somehow help to make Linq possible. While anonymous types have shown up pretty explicitly and you can see from the lack of type annotations we have been writing that there is some type inference going on, where are the extension methods and lambda expressions?

There's a principle in language design and implementation called "syntactic sugar". We use this to describe cases where certain syntax isn't directly compiled, but is first transformed into some other more primitive syntax and then passed to the compiler. This is exactly what happens with Linq: your queries are transformed into a sequence of method calls and lambda expressions.

The C# 3.0 specification goes into great detail about these transformations. In practice, you probably don't need to know about this, but let's look at one example to help us understand what is going on. Our simple query from earlier: 
var Found = from o in Orders
          where o.CustomerID == 84
          select o.Cost;
 After transformation by the compiler, becomes: 
var Found = Orders.Where(o => o.CustomerID == 84)
                      .Select(o => o.Cost);
And this is what actually gets compiled. Here the use of lambda expressions becomes clear. The lambda passed to the Where method is called on each element of Orders to determine whether it should be in the result or not. This produces another intermediate collection, which we then call the Select method on. This calls the lambda it is passed on each object and builds up a final collection of the results, which is then assigned to Found. Beautiful, huh?

Finally, a note on extension methods. Both Where and Select, along with a range of other methods, have been implemented as extension methods. The type they use for "this" is IEnumerable, meaning that any collection that implements that interface can be used with Linq. Without extension methods, it would not have been possible to achieve this level of code re-use.

DLinq and XLinq 
 In this article I have demonstrated Linq working with objects instantiated from classes that we implemented ourselves and stored in built-in collection classes that implement IEnumerable. However, the query syntax compiles down to calls on extension methods. This means that it is possible to write alternative implementations of Linq that follow the same syntax but perform different operations.

Two examples of this, which will ship with C# 3.0, are DLinq and XLinq. DLinq enables the same language integrated query syntax to do queries on databases by translating the Linq into SQL. XLinq enables queries on XML documents.

Conclusion 
 Linq brings declarative programming to the C# language and will refine and unify the way that we work with objects, databases, XML and whatever anyone else writes the appropriate extension methods for. It builds upon the language features that we have already seen in the previous parts of the series, but hiding some of them away under syntactic sugar. While the query language has a range of differences to SQL, there are enough similarities to make knowledge of SQL useful to those who know it. However, its utility is far beyond providing yet another way to work with databases.

Closing Thoughts On C# 3.0 
 This brings us to the end of this four part series on C# 3.0. Here is a quick recap on all that we have seen. 
Type inference removes much of the tedium of writing out type annotations again and again. 
Lambda expressions make higher order programming syntactically light. 
Extension methods provide another path to better code re-use when correctly applied. 
Object and collection initializers along with anonymous types make building up large data structures much less effort. 
Linq gives us declarative programming abilities over objects, databases and XML documents. 
When I saw C# 1.0 I highly doubted that C# was going to be a language I would ever be excited about. I have been pleasantly surprised, and writing this series has been a lot of fun. I hope that it has been informative and enjoyable to read, and that it will help you to make powerful use of the new language features. I greatly look forward to being able to use them in my own day-to-day development and seeing how other people use them.

Of course, knowing about something and doing it yourself are two entirely different things; if you haven't already done so, grab yourself the Visual Studio 2008 trial or the free Express Edition. Only then will you become comfortable with the new features and be able to use them effectively in your own development. Happy hacking, and have fun!