Extras

Answer: A

Max is one of the aggregation operators, which are implemented as extension methods in System.Linq.Enumerable and System.Linq.Queryable.

Max returns the maximum value calculated by the lambda expression, not the element that had the maximum value.

Answer: D

This throws an InvalidOperationException: the sequence emitted by OrderBy contains four elements, and Single demands exactly one element. To get the result "red", you must use the First operator instead:

colors.OrderBy (c => c.Length).First()

Another option is to use FirstOrDefault (unlike First, FirstOrDefault doesn't throw an exception there are zero elements in the sequence).

Single is good for retrieving a row from a table by primary key, in a LINQ to SQL query:

Customer c =
  dataContext.Customers.Single (c => c.ID == 123);

In this case, you'd want an exception to be thrown if there were two customers with that ID.

Answer: D

The compiler translates this query to:

IEnumerable<string> query = colors
  .Where   (c => c.Length > 3)
  .OrderBy (c => c.Length);

The Where and OrderBy methods, in this case, resolve to Enumerable.Where and Enumerable.OrderBy, which both return IEnumerable<T>. T is inferred to be string because we haven't transformed or projected the input sequence elements in any way.

Answer: C

The variable, c, inside the subquery, conflicts with the outer query's iteration variable, so the compiler complains.  Here's how to fix it:

var query =
  from c in colors
  where c.Length == colors.Max (c2 => c2.Length)
  select c;

The answer is then (A).

Answer: D

With local queries, subqueries re-evaluate for each element in the outer sequence. This is somewhat inefficient: we could avoid this by factoring out the subquery as follows:

int maxLength = colors.Max (c => c.Length);

var query
  from c in colors
  where c.Length == maxLength
  select c;  

The Max query then executes just once.

Answer: A

Queries execute not when constructed, but when enumerated. This is called lazy or deferred evaluation. Our query doesn't start executing until it encounters the aggregation operator, Count, which forces immediate enumeration. By that stage, red has been removed from the collection.

Any query operator that returns a scalar value or single element (such as Single or First) forces immediate execution.

Answer: A

We've chained one Where operator after another, so that our final query considers only strings containing both the letters e and n (only green). Our query is compositionally identical to this:

var query = colors
  .Where (c => c.Contains ("e"))
  .Where (c => c.Contains ("n"));

and gives the same result as this:

var query = colors
  .Where (c => c.Contains ("e")
            && c.Contains ("n"));

Answer: B

This query looks very much like the last one, but the result is very different! Because the variable s is referenced from within a lambda expression, it's captured by the compiler and becomes an outer variable.

With an outer variable, what matters is its value at the time the query executes—not its value at the time the query was constructed. In our example, both Where operators end up using "n" in their predicates, because this is the value of s when the query was actually enumerated.

Answer: C

Here's how the compiler translates this query:

colors.Select (
  c => new
    {
      c = c, 
      middle = c.Substring (1, (c.Length - 2))
    }
  )
  .Where (temp0 => temp0.middle.Contains ("e"))
  .Select (temp0 => temp0.middle)

To see how the compiler translates comprehension queries, replace colors with colors.AsQueryable(), and then run the query in LINQPad. The translation displays in the lambda tab.

Answer: B

Queries containing multiple generators translate to SelectMany.  LINQ to SQL, in turn, translates SelectMany into a variety of SQL constructs, including inner and outer SQL joins.

Answer: I and IV

Answer: II and V (in conjunction with DefaultIfEmpty)

With LINQ to SQL, SelectMany-based joins are the most flexible, and can perform both equi and non-equi joins. Throw in DefaultIfEmpty, and you can do left outer joins as well!

Here's an example of a simple inner join:

from c in dataContext.Customers
from i in dataContext.Invoices
where c.CustomerID == i.CustomerID
select ...

Or, using an association property:

from c in dataContext.Customers
from i in c.Invoices
select ...

A left outer join:

from c in dataContext.Customers
from i in dataContext.Invoices
  .Where (i => c.CustomerID == i.CustomerID)
  .DefaultIfEmpty()
select ...

 Or, using an association property:

from c in dataContext.Customers
from i in c.Invoices.DefaultIfEmpty()
select ...

Here's an non-equi inner join that queries post codes that cross states:

from t1 in dataContext.Towns
from t2 in dataContext.Towns
where t1.PostCode == t2.PostCode
      && t1.State.CompareTo (t2.State) < 0
select ...

We can turn this into an non-equi outer join as follows:

from t1 in dataContext.Towns
from t2 in dataContext.Towns
  .Where (t => t.PostCode == t1.PostCode
            && t.State.CompareTo (t1.State) < 0)
  .DefaultIfEmpty()
select ...

Answer: I

Answer: II (in conjunction with DefaultIfEmpty)

Join is the not as powerful than SelectMany in LINQ to SQL (it cannot perform non-equi-joins.)

The big advantage of Join over SelectMany is not in LINQ to SQL, but in local queries: Join is much faster with large collections because it preloads the inner sequence into a keyed lookup.

Answer: B

In a LINQ to SQL query, you cannot include calls to your own local methods (or unsupported Framework methods) in any place other than the final projection. If you try to do otherwise, one of two things will happen:

• LINQ to SQL will throw an exception when the query executes ("method XYZ has no translation to SQL")
• the query will be executed locally from that point on.

You can force the second scenario by calling  AsEnumerable on the query. For instance, the following uses a LINQ to SQL query to retrieve all articles on influenza, and then uses a local query to narrow the results down to only those articles whose abstract is less than 100 words:

var wordCounter = 
  new System.Text.RegularExpressions.RegEx (
    @"\b(\w|[-'])+\b");

var query = dataContext.Articles
  .Where (a => a.Topic == "influenza")
  .AsEnumerable()
  .Where (a => 
    wordCounter.Matches (a.Abstract).Count < 100
  );

We have to run the regular expressions filter locally, because Regex has no translation in SQL.

Answer: D

Here's an example:

var options = new DataLoadOptions();
options.LoadWith <Customer> (c => c.Orders);
dataContext.LoadOptions = options;

This ensures that when a customer is retrieved, so are the customer's orders.

Answer: A

An XElement can have only one parent. When you try and make city also the child of customer2, LINQ to XML automatically makes a deep clone of city, rather than throwing an exception.

Answer: A

Child XElements do not implicitly inherit a namespace from their parent. Here's what the XML serialization of our DOM would look like:

<customer xmlns="http://albahari.com/linqquiz">
     <name xmlns="">Bloggs</name>
</customer>

If we wanted answer (B), we'd have to construct the DOM in the following manner instead:

var x =
  new XElement (ns + "customer",
    new XElement (ns + "name", "Bloggs")
  );

This would translate to the following XML:

<customer xmlns="http://albahari.com/linqquiz">
     <name>Bloggs</name>
</customer>

Answer: A

An XML declaration is always written, unless you instead provide an XmlWriter and instruct the writer explicitly not to emit the declaration.

With an XDocument, the presence of an XDeclaration has no effect on whether an XML declaration is written. An XDeclaration merely hints the writer as to what encoding to use, and what to put in the standalone attribute.