Lambda Expressions



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.

 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);
                                                                                                     Author : C#corner

Comments

Post a Comment

Popular posts from this blog

SQL Server Indexes

Image
Relational databases like SQL Server use indexes to find data quickly when a query is processed. Creating and removing indexes from a database schema will rarely result in changes to an application's code; indexes operate 'behind the scenes' in support of the database engine. However, creating the proper index can drastically increase the performance of an application. The SQL Server engine uses an index in much the same way a reader uses a book index. For example, one way to find all references to INSERT statements in a SQL book would be to begin on page one and scan each page of the book. We could mark each time we find the word INSERT until we reach the end of the book. This approach is pretty time consuming and laborious. Alternately, we can also use the index in the back of the book to find a page number for each occurrence of the INSERT statements. This approach produces the same results as above, but with tremendous savings in time. When a SQL Server has ...
Read more

C# Constructor

C# Constructor and its Types – A Detailed Look Definition: In simple terms, Constructor is a special kind of method with class name as method name and gets executed when its (class) object is created. This article will give you a detailed explanation on C# constructors and its types. Now, when we look at the above definition in a broader sense, a constructor is a class method that gets automatically executed whenever class’s object is created or whenever class is initialized.   Consider following bit of code: public class MsDotNetHeaven     {         public MsDotNetHeaven()          {               //A default Constructor          }       //Class members     } In the above snippet, the method MsDotNetHeaven() is called the constructor of class MsDotNetHeaven, also called default constructor. Behind the scenes What happen...
Read more