Lambda Expressions and Delegates

320 Part III Creating Components

When the stopMachinery delegate is invoked, it calls FinishFolding, which in turn calls the StopFolding method, passing in the parameter of 0.

Note The FinishFolding method is a classic example of an adapter, a method that converts (or

adapts) a method to give it a different signature. This pattern is very common and is one of the set of patterns documented in the book Design Patterns: Elements of Reusable Object-Oriented Architecture by Gamma, Helm, Johnson, and Vlissides (Addison-Wesley Professional, 1994).

In many cases, adapter methods such as this are small, and it is easy to lose them in a sea of methods, especially in a large class. Furthermore, apart from using it to adapt the StopFolding

method for use by the delegate, it is unlikely to be called elsewhere. C# provides lambda expressions for situations such as this.

Using a Lambda Expression as an Adapter

A lambda expression is an expression that returns a method. This sounds rather odd because most expressions that you have met so far in C# actually return a value. If you are familiar with functional programming languages such as Haskell, you are probably comfortable with this concept. For the rest of you, fear not: lambda expressions are not particularly complicated, and after you have gotten used to a new bit of syntax, you will see that they are very useful.

You saw in Chapter 3, “Writing Methods and Applying Scope,” that a typical method consists of four elements: a return type, a method name, a list of parameters, and a method body. A lambda expression contains two of these elements: a list of parameters and a method body.

Lambda expressions do not define a method name, and the return type (if any) is inferred from the context in which the lambda expression is used. In the StopFolding method of the FoldingMachine class, the problem is that this method now takes a parameter, so you need to create an adapter that takes no parameters that you can add to the stopMachinery delegate.

You can use the following statement to do this:

this.stopMachinery += () => { folder.StopFolding(0); };

All of the text to the right of the += operator is a lambda expression, which defines the method to be added to the stopMachinery delegate. It has the following syntactic items:

A list of parameters enclosed in parentheses. As with a regular method, if the method you are defining (as in the preceding example) takes no parameters, you must still provide the parentheses.

The => operator, which indicates to the C# compiler that this is a lambda expression.

The body of the method. The example shown here is very simple, containing a single statement. However, a lambda expression can contain multiple statements, and you can

format it in whatever way you feel is most readable. Just remember to add a semicolon after each statement as you would in an ordinary method.

Strictly speaking, the body of a lambda expression can be a method body containing multiple statements, or it can actually be a single expression. If the body of a lambda expression contains only a single expression, you can omit the braces and the semicolon (you still need a semicolon to complete the entire statement), like this:

this.stopMachinery += () => folder.StopFolding(0) ;

When you invoke the stopMachinery delegate, it will run the code defined by the lambda expression.

The Form of Lambda Expressions

Lambda expressions can take a number of subtly different forms. Lambda expressions were originally part of a mathematical notation called the Lambda Calculus that provides a notation for describing functions. (You can think of a function as a method that returns a value.) Although the C# language has extended the syntax and semantics of the Lambda Calculus in its implementation of lambda expressions, many of the original principles still apply. Here are some examples showing the different forms of lambda expression available in C#:

x => x * x // A simple expression that returns the square of its parameter

//The type of parameter x is inferred from the context.

x=> { return x * x ; } // Semantically the same as the preceding

//expression, but using a C# statement block as

//a body rather than a simple expression

(int x) => x / 2 // A simple expression that returns the value of the

//parameter divided by 2

//The type of parameter x is stated explicitly.

() => folder.StopFolding(0) // Calling a method

//The expression takes no parameters.

//The expression might or might not

//return a value.

(x, y) => { x++; return x / y; } // Multiple parameters; the compiler

//infers the parameter types.

//The parameter x is passed by value, so

//the effect of the ++ operation is

//local to the expression.

(ref int x, int y) { x++; return x / y; } // Multiple parameters

//with explicit types

//Parameter x is passed by

//reference, so the effect of

//the ++ operation is permanent.

Lambda Expressions and Anonymous Methods

Lambda expressions are a new addition to the C# language in version 3.0. C# version 2.0 introduced anonymous methods that can perform a similar task but that are not as flexible. Anonymous methods were added primarily so that you can define delegates without having to create a named method; you simply provide the definition of the method body in place of the method name, like this:

this.stopMachinery += delegate { folder.StopFolding(0); };

You can also pass an anonymous method as a parameter in place of a delegate, like this:

control.Add(delegate { folder.StopFolding(0); } );

Notice that whenever you introduce an anonymous method, you must prefix it with the delegate keyword. Also, any parameters needed are specified in braces following the delegate keyword. For example:

control.Add(delegate(int param1, string param2) { /* code that uses param1 and param2 */ ... });

After you are used to them, you will notice that lambda expressions provide a more succinct syntax than anonymous methods do and they pervade many of the more advanced aspects of C#, as you will see later in this book. Generally speaking, you should use lambda expressions rather than anonymous methods in your code.