|
by
Granville Barnett | 24 September 2007
In the
previous page, we wrapped our look at how LINQ and XML
work. The final topic that I will cover in this page
concerns lambda expressions. Read on to find out more!
Many people find lambda expressions fairly hard to get to
grips with, so we will take some time to create some basic
lambda expressions and then replicate some queries of
in-memory collections and relational data using lambda
expressions. If you have ever done any functional
programming before in a language such as Haskell or F# then
you will be familiar with the syntax of lambda expressions –
if you have no experience with either, then don’t worry. We
will go through lambda expressions now with a series of
practical examples.
The first thing to clear up is the basic structure of a
lambda expression; this takes the form of args =>
expression. For the first example we will create a function
that returns the square of any given integer argument:
- Func<int,
int>
square
= x
=> x
* x;
- Console.WriteLine(square(3));
In this example we create a lambda expression that takes
one argument (x) of type int, and returns an int. To the
left of the => token is our single argument, and to the
right of the => token is our expression (x*x).
Let’s now apply what we have just learned to filtering an
in-memory collection. Just as before, our lambda expression
will take a single argument, but this time return a Boolean
value determined by whether or not the argument satisfied
the expression:
- List<string>
people
= new
List<string>(){
"Granville",
-
"Rachel",
-
"John",
-
"Ross",
-
"Monica" };
-
- IEnumerable<string>
expr =
people.Where(x
=> x.Length
> 4);
- foreach
(string
person
in
expr)
{
- Console.WriteLine(person);
- }
Here we pass in an inline lambda expression to the Where
extension method, in this case the parameter is of type
string and the expression returns true only if the string
has a length of greater than four characters.
For our final example we will use a lambda expression to
select only the AuthorName property of the Author entity
instead of creating an anonymous type. First we show how we
would do this returning an anonymous type:
- BookShop
db =
new
BookShop(_conn);
-
- var
authors
=
from a
in
db.Authors
-
select
new {
a.AuthorName
};
-
- foreach
(var
author
in
authors)
{
- Console.WriteLine(author.AuthorName);
- }
Next we perform the same operation using a lambda
expression:
- BookShop
db =
new
BookShop(_conn);
-
- IEnumerable<string>
authors
= db.Authors.Select(x
=> x.AuthorName);
- foreach
(string
author
in
authors)
{
- Console.WriteLine(author);
- }
I strongly recommend that you familiarize yourselves with
lambda expressions as they are incredibly useful when using
LINQ. At the time of writing lambda expressions look set to
become the de facto standard, with anonymous delegates
playing a more subdued role in the future C# 3.0 language.
The simplicity and flexibility of LINQ has been shown
throughout this article – it truly provides developers with
a consistent language to query several data stores via
several methods. An important fact to remember is that LINQ
is still in early CTP stages, so logically it will only get
better! I encourage everyone to further explore what LINQ
can do, and more importantly how it can make your life a lot
easier.
If you have any questions, please contact me or post on
the forums.
|
Further Exploration with LINQ - Page 4
