C# in Depth

234 CHAPTER 9 Lambda expressions and expression trees9.1.3 Using a single expression as the bodyThe form we’ve seen so far uses a full block of code to return the value. This is veryflexible—you can have multiple statements, perform loops, return from differentplaces in the block, and so on, just as with anonymous methods. Most of the time,however, you can easily express the whole of the body in a single expression, the valueof which is the result of the lambda. In these cases, you can specify just that expression,without any braces, return statements, or semicolons. The format then is(explicitly-typed-parameter-list) => expressionIn our case, this means that the lambda expression becomes(string text) => text.LengthThat’s starting to look simpler already. Now, what about that parameter type? Thecompiler already knows that instances of Func take a single stringparameter, so we should be able to just name that parameter…9.1.4 Implicitly typed parameter listsMost of the time, the compiler can guess the parameter types without you explicitlystating them. In these cases, you can write the lambda expression as(implicitly-typed-parameter-list) => expressionAn implicitly typed parameter list is just a comma-separated list of names, without thetypes. You can’t mix and match for different parameters—either the whole list isexplicitly typed, or it’s all implicitly typed. Also, if any of the parameters are out or refparameters, you are forced to use explicit typing. In our case, however, it’s fine—soour lambda expression is now just(text) => text.LengthThat’s getting pretty short now—there’s not a lot more we could get rid of. The parenthesesseem a bit redundant, though.9.1.5 Shortcut for a single parameterWhen the lambda expression only needs a single parameter, and that parameter canbe implicitly typed, C# 3 allows us to omit the parentheses, so it now has this form:parameter-name => expressionThe final form of our lambda expression is thereforetext => text.LengthYou may be wondering why there are so many special cases with lambda expressions—none of the rest of the language cares whether a method has one parameter or more,for instance. Well, what sounds like a very particular case actually turns out to beextremely common, and the improvement in readability from removing the parenthesesfrom the parameter list can be significant when there are many lambdas in a shortpiece of code.Licensed to Rhona Hadida