LINQ adds features to C# that allow static SQL-like expressions to be used for querying data collections. Key features added include lambda expressions, extension methods, expression trees, list comprehension, anonymous types, and type inference. These features allow C# code to represent SQL queries as code that can then be translated to underlying data sources like databases. Expression trees in particular allow the lambda expressions to be represented as syntax trees that can be converted to executable queries like SQL at runtime. Many of the features added to C# with LINQ came from functional programming languages.

1. Putting it all together:
LINQ as an Example
The Problem: SQL in Code
• Programs often connect to database servers.
• Database servers only “speak” SQL.
• Programs have to construct SQL strings.
• PHP example:
if (some_condition()) {
$q = mysql_query(“select name from user were id = $id”)
...
}
• When will the problem be detected?
2

2. 3
Searching in Collections
• Begin with a simple array of, say,
Customers.
Customer[] customers = new Customer[30];
customers[0] = new Customer(…);
…
customers[29] = new Customer(…);
4
Searching in Collections:
The Old Way
• Find the names of all London customers:
List<string> londoners = new List<string>();
foreach (Customer c in customers) {
if (c.City == “London”) {
londoners.add(c.Name);
}
}

3. 5
Searching in Collections:
The LINQ Way
string[] londoners =
from c in customers
where c.City == “London”
select c.Name;
Declarative!
SQL-like!
No loops!
Returns a simple array!
Searching in Collections:
The LINQ Way
• LINQ is a C# feature
– Introduced in C# 3.0.
• LINQ = “Language INtegrated Query”
• So far, this is just list comprehension
added to C#.
• What did it take to add list
comprehension to the language?

4. 7
LINQ: How Does It Work?
• LINQ syntax = shorthand for method
invocation.
• Syntactic sugar, using “Translation
maps”
8
Syntax Translation Example
string[] londoners =
from c in customers
where c.City == “London”
select c.Name;
string[] londoners =
customers.
Where(expression).
Select(expression);

5. 9
Expressions == Methods?
• Where() wants a Boolean method.
• The method acts as a filter.
• Likewise for Select(): a translation
method.
10
Translating Expressions
• Problem: Translating
“c.City == “London””
to a boolean expression e, such that
Where(e) is valid?

6. 11
C# Delegates
• C# delegates: method pointers.
• Since C# 1.0.
class Demo {
delegate void Foo();
void Bar() { … do something … };
void Test() {
Foo myDelegate = new Foo(Bar);
// “pointer” to Bar()
myDelegate(); // invoke
}
}
12
Delegates as Arguments
• Delegates can be passed as
arguments.
– Event handlers, jobs for threads, etc.
class Demo {
void Job() { … the job to carry out … };
void Test() {
Thread worker = new Thread(
new ThreadStart(Job));
worker.start();
}
}

7. 13
Anonymous Methods
• Nameless methods = on-the-fly
delegates:
class Demo {
delegate void Foo();
void Test() {
Foo myDelegate = delegate() {
… do something …
};
myDelegate(); // invoke
}
}
14
Syntax Translation Example
string[] londoners =
from c in customers
where c.City == “London”
select c.Name;
string[] londoners =
customers.
Where(delegate(Customer c) {
return c.City == “London”; }).
Select(delegate(Customer c) {
return c.Name });

8. 15
Well, Not Really.
•Where(), etc. accept delegate
methods.
• But LINQ creates lambda
expressions.
• Seamless conversion via
coercion.
16
Syntax Translation Example
string[] londoners =
from c in customers
where c.City == “London”
select c.Name;
string[] londoners =
customers.
Where(c => c.City == “London”).
Select(c => c.Name);

9. 17
Lambda Expressions
• Lambda expression syntax:
(argumentList) => expression
oneArgument => expression
• Arguments optionally typed.
– Type inference mechanism.
– More on that later…
Shades of ML…
18
Where’s Where()?
• We invoked Where() on
Customers[].
• On the resulting Customers[], we
invoked Select().
• New methods for arrays!?

10. 19
Extension Methods
class Utils {
public static firstChar(this string s)
{
return s.charAt(0);
}
}
• So far, just a simple static method.
• Can be used like any other.
20
Extension Methods
• But now…
Using Utils;
class Demo {
void Foo() {
string s = “Hello”;
Console.WriteLine(s.firstChar());
}
}

11. 21
Extension Methods
• Static methods that seem to extend
existing types.
• Where(), Select(), etc. extend array
types in this manner.
22
Query Your Own Types!
• LINQ can be applied to any type,
not just built-in arrays and lists.
• Just implement Where(),
Select(), etc.

12. 23
LINQ and Relational Data
• Let’s obtain a DB-table type, and query it.
DbCustomers customers = new DbCustomers(“my.mdb”);
string[] londoners =
from c in customers
where c.City == “London”
select c.Name;
24
This Makes No Sense!
• But… Where() applies the filter to
every record.
• … on the client!
• SELECT * FROM CUSTOMERS, and
filter with a simple loop!?

13. 25
Back To Lambda
Expressions
• Lambda expressions can be
converted to anonymous methods.
• Can also be coerced to expression
trees.
– A run-time representation of the
syntax tree.
26
Example…
• Our code yields:
string[] londoners = customers.
Where(c => c.City == “London”).
Select(c => c.Name);
where “customers” is of type DbCustomers.
• No
DbCustomers.Where(delegate(Customer c))
method exists.
• However:
DbCustomers.Where(
Expression<Func<Customer,bool>> xt)

14. 27
What Are Expression Trees?
• Any valid expression is converted by the
compiler to an expression tree.
– a.k.a. the abstract syntax tree of the expression.
– Normal part of the compilation process, in any language!
• Examples:
5 + 3 * 2 c.city == “London”
+
5 *
3 2
==
. (dot) “London”
c city
28
Expression Trees
• Normally, expression trees only exist at
compile-time.
• In C#, the compiler can create a run-time
representation of the expression tree.
– The language has a data type for expression trees.
– Represents lambda expressions at runtime.
• Used for generating SQL at runtime.
– Guaranteed to be syntactically valid, since it
was created from a valid C# expression.

15. It’s Just Coercion
• So, LINQ converts into expressions that
use Where(...), Select(...), etc.
• For some classes, Where(...) and
Select(...) accept delegates; for other
classes, they accept expression trees.
• Lambda expressions can be coerced
into either.
29
30
Projections
• Using LINQ’s select:
from c in customers
where c.City == “London”
select
new AddressBookEntry(c.Name, c.Phone);

16. 31
Pre-Defined Types Only?
• But…
The projection type (e.g.,
AddressBookEntry) must be pre-
defined!
32
Ad-Hoc Types
• new { [name1 =] expr1,…, [ namen =] exprn}
• Type implied by types of exprs.
• Example:
from c in customers
where c.City == “London”
select new { c.Name, c.Phone };
If name is not specified, and
expr is either property or
x.property, then property’s
name will be used.

17. 33
Ad-Hoc Types are Nameless
• How do we store the result?
??? q = from … select new {…};
• The ad-hoc type is nameless!
34
Auto-Typed Variables
• var x = 7; // x will be of type int
• var q = from … select new {…};
// q will be an array of the anonymous type
Console.WriteLine(q[0].Name);
• Local variables only.
– No auto-typing for fields or formal parameters.

18. Summary
• LINQ adds static SQL expression
correctness to C#.
• To do this, the following features were
added to C#:
– Lambda expressions.
– Extension methods.
– Expression types.
– List comprehension.
– Anonymous data types.
– Type inference.
35
There’s More
• There are several LINQ features we did
not present here, such as:
– Grouping (“GROUP BY” in SQL)
– Joins (selecting from multiple tables)
– ...
• These require even more language
features, such as closures.
36

19. What Is Happening to Languages?
• As new features are added to programming
languages, the languages evolve.
• Many of the features come from research or
experimental languages.
• Note how many of the new C# features
discussed here come from functional
languages like ML, Haskell or LISP:
– Lambda expressions, expression types, list
comprehension, anonymous data types, type
inference...
37
“Confessions of a Used Programming
Language Salesman”
• An 2007 essay by Eric Meijer (Microsoft).
• Discusses how features from functional
languages slowly creep into “mainstream”
languages.
• “Functional programming has finally reached
the masses, except that it is called Visual
Basic 9 instead of Haskell 98”.
38

20. A Glimpse Into the Future:
LISP (1958)
• We have seen the power of representing
program source at runtime (expression
trees).
• In LISP, program source can be
represented at runtime, but also generated
at runtime (or compile-time).
– Source code itself is a data structure (a list).
• LISP macros are light-years ahead of
C/C++ macros.
39
A Glimpse Into the Future:
LISP (1958)
• 50 years later, LISP features are slowly
re-appearing in mainstream languages.
– e.g., garbage collection, aspect-oriented
programming, and more.
• Conclusions:
– a. Learn from history.
– b. Know LISP, Haskell, etc: once you really
understand them, it will give you serious
advantages over ignorant software engineers
(even if you never use these languages in
practice).
40