Lambda expressions
are part of .Net 3.0. They are used extensively in Linq, but they can also be
used on their own. With Lambda expressions, filtering and sorting Lists has
become a lot easier.
In my examples,
I'm going to filter and sort Lists of Employee objects:
public class Employee
{
public string FirstName {set;get;}
public string LastName {set;get;}
public decimal Salary {set;get;}
public bool IsManager {set;get;}
} |
FindAll( )
Suppose I have a List of Employees, and I want to find all the managers. At one
point I would have written code like this:
List<Employee> managers = new List<Employee>( );
foreach (Employee employee in employees)
{
if (employee.IsManager == true)
managers.Add(employee);
}
|
The new syntax with Lambda expressions is clean and simple:
List<Employee> managers = employees.FindAll(employee => employee.IsManager == true);
|
Note that the term "employee" was used to make things clear. I could have used
any other name. For example:
List<Employee> managers = employees.FindAll(e => e.IsManager == true);
|
Where( )
Where( ) works exactly the same way as FindAll( ). In some cases, using Where(
) instead of FindAll( ) can make your code easier to understand.
Here, for example, is a different way to
find all the managers:
using System.Linq;
foreach (Employee employee in employees.Where(e => e.IsManager == true))
{
// do something
}
|
Find( )
Find( ) returns the first object in a list which meets my search criteria. If
no object meets my criteria, it returns null.
Employee firstManager = employees.Find(employee => employee.IsManager == true);
if (firstManager == null)
Console.WriteLine("No managers found in list.");
|
ForEach( )
ForEach( ) can be used to perform an operation on each item in a List. In this
example we are adding 100 to the Salary of each Employee:
employees.ForEach(e => e.Salary += 100);
|
OrderBy( ) and OrderByDescending( )
OrderBy( ) returns a List sorted in ascending order. OrderByDescending( )
returns a List sorted in descending order.
This only works if there is an appropriate
method to do the comparison. For basic data types (e.g., string, int, decimal,
etc.), Lambda expressions make sorting easy:
using System.Linq; List<Employee> sortedList = employees.OrderBy(e => e.Age).ToList();
|
Note that the original List, employees, is unchanged. Of course, you could sort
the employees List itself as follows:
employees = employees.OrderBy(e => e.Age).ToList();
|
To sort in descending order:
List<Employee> sortedList = employees.OrderByDescending(e => e.Age).ToList();
|
Sort( )
Sort( ) provides an alternative to OrderBy( ):
employees.Sort((e1, e2) => e1.DOB.CompareTo(e2.DOB));
|
Note that Sort( ) operates on the orginal List, employees. That is, there is no
need to do this:
employees = employees.Sort((e1, e2) => e1.DOB.CompareTo(e2.DOB));
|
because employees is already sorted.
Getting Fancy
If I make an enum like this:
public enum SortOrder { Ascending, Decending }
|
and I add this method to the Employee class:
public static void Sort<TKey>(ref List<Employee> list, Func<Employee, TKey> sortKey,
SortOrder sortOrder)
{
if (sortOrder == SortOrder.Ascending)
list = list.OrderBy(sortKey).ToList();
else
list = list.OrderByDescending(sortKey).ToList();
}
|
Now I can sort my List of Employees like this:
Employee.Sort(employees, e => e.Salary, SortOrder.Ascending);
|
or this:
Employee.Sort(employees, e => e.LastName, SortOrder.Descending);
|
In this article, I've only discussed the use of Lambda expressions to sort and
filter Lists of objects.
If that were the only use for Lambda
expressions, they would still be a major time saver - a fantastic new addition
to .Net. Lambda expressions, however, have many uses.
Once you get started, you will wonder
how you ever managed without them.
Enjoy.