Lambda (11th Letter of Greek Alphabet) Popularized by Python and Ruby, the lambda expression is a powerful shorthand that can be used to significantly speed up c# development. This post deals entirely with using lambda expressions in everyday development, and sidesteps the esoteric mathematical logic that makes them intimidating.

 

Lambda What?

 

A Lambda expression in c# is simply a piece of syntactical sugar for fleshing out a function body where you would normally plug in a delegate (pointing to a function somewhere else). This saves you two or three lines of code per call, speeding up your development (where delegates are required) to light speed and making your code more maintainable.

Because lambdas can only be used where delegates are required, your initial benefit from learning them may be limited. Before looking into lambdas, I avoided using functions in the .NET base class library that required delegates because of the added hassle. Now, after learning how to use lambdas, I seek them out!

Lastly, are you familiar with anonymous methods? Lambda expressions are very similar – just a slightly shorter syntax. Anonymous methods and lambdas compile to the same intermediate language (and have the same performance as a result).

 

 

What does a lambda expression look like?

 

LambdaIdentify 

In the example above, Name => Name.StartsWith(“O”) is the lambda expression. All it does is check if the “Name” passed into it starts with a given letter and returns True/False. The Find() function (not lambda-related) runs this lambda expression against each list item until a match is found. You could use a delegate to another function (like the one below) or an anonymous method in its place, but it would be a lot more code either way.

 

This expression is roughly equivalent to the non-lambda function:

equiv 

(Which could have been plugged into FruitNames.Find() using a delegate by the way. All that was accomplished by using the lambda was saving a few lines of code.)

 

“Name”

Name is the function argument. We could have named this “FruitName”, “F”, or anything else. However, we would have had to remember to change it in the function body at the same time. Lambdas automatically infer variable types from the parent signature. In this case, StartsWith() requires a single string argument, causing “Name” to typed as a string.

 

“=>”

This is the important symbol that tells c# that you are using a lambda expression. It is absolutely required for every lambda expression that you write. Arguments go on the left and your function body goes on the right. Read as “goes to”.

 

“Name.StartsWith(“O”)”

Is plain c# and also the meat of the expression. This simply returns true if the function argument “Name” begins with the letter “O” or false if it does not. In this example, it’s only one line. However, lambdas may be expanded to multiple lines (just wrap your function body in squiggly brackets like any other method) In this case, it is required that we return a Boolean because the parent “Find()” requires a Predicate (Boolean return type):

findreq

(Predicate simply takes in one argument of a given type and returns a Boolean)

 

 

Real-World Examples

Now that you have a basic understanding of what a lambda expression is, and how it might be useful (less code), take a look at a few practical code examples.

 

Predicate Delegates

A predicate is just a function that returns true or false. Imagine helping a friend sort through a box of old items. You pick up each item out of the box and your friend (after looking at the item) either says “throw away” or “keep”. Your friend is acting as a predicate.

Predicates are extremely useful for filtering lists of items and you will find them throughout the framework for this reason. In the first example in this article we used a predicate to sort through a list of fruit by looking at the first letter of each fruit name.

Here is another example using objects instead of strings:

 

   1: private class Book
   2:  {
   3:      public string Author { get; set; }
   4:      public string Name { get; set; }
   5:      public DateTime Published { get; set; }
   6:  }
   7:  
   8:  //Create and fill a list of books
   9:  private List<Book> Books = new List<Book> { 
  10:      new Book { Author="Mcconnell",Name="Code Complete", Published=new DateTime(1993,05,14) },
  11:      new Book { Author="Sussman",Name="SICP (2nd)", Published=new DateTime(1996,06,01) },
  12:      new Book { Author="Hunt",Name="Pragmatic Programmer", Published=new DateTime(1999,10,30) },
  13:  };
  14:  
  15:  
  16:  private IEnumerable<Book> BooksPublishedAfter1995()
  17:  {
  18:      return Books.FindAll(Book => Book.Published > new DateTime(1995, 12, 31));
  19:  }

 

In this example “BooksPublishedAfter1995()” uses a lambda expression as a predicate to compare each when each book was published to a specific date. This function returns a new collection of books containing just SICP and Pragmatic Programmer.

Here’s the a similar multiline lambda that returns books published between 1991 and 1997:

 

   1: private IEnumerable<Book> BooksPublishedBetween1991and1997()
   2: {
   3:     return Books.FindAll(Book => {
   4:  
   5:         return Book.Published >= new DateTime(1991, 01, 01) &&
   6:         Book.Published <= new DateTime(1997, 12, 31);
   7:     
   8:     });
   9: }

 

As you can see, it would be excessive to type out a separate function just for this simple piece of logic. Lambda statements are ideal for this type of filtering.

 

Don’t Forget to stay DRY

(Don’t Repeat Yourself) Lambdas and anonymous methods are a power tools that should be used carefully. Remember to identify and move common predicates into shared functions early instead of using repeated Lambdas throughout your code and creating a maintenance nightmare.

 

 

Absolutely Minimalistic Threading

It is possible to spawn new threads using just the code contained in the lambda statement. In fact, you can do it in only a few lines. A good example for this is when you need to open up a webpage in the default browser from a windows forms application but don’t want the user interface to skip a beat or lock up (as is the case with some firewall software). Lambda expressions paired with a new thread will do the trick:

 

   1: (new System.Threading.Thread1))=> {
   2:  
   3:     try
   4:     {
   5:         System.Diagnostics.Process.Start("http://www.example.com");
   6:     }
   7:     catch (Win32Exception StartException)
   8:     {
   9:         //Likely caused by firewall software such as ZoneAlarm
  10:         MessageBox.Show("Failed to open URL.");
  11:     }
  12:  
  13: }.Start();

 

If you look carefully, you will notice that “()” is used on the left hand side of the lambda. This simply indicates that no arguments are to be used.

For more cool threading lambda expression examples for c#, have a look at my Threading Tips and Tricks post.

References   [ + ]

1. )=> {
   2:  
   3:     try
   4:     {
   5:         System.Diagnostics.Process.Start("http://www.example.com");
   6:     }
   7:     catch (Win32Exception StartException)
   8:     {
   9:         //Likely caused by firewall software such as ZoneAlarm
  10:         MessageBox.Show("Failed to open URL.");
  11:     }
  12:  
  13: }