Generic Lambda Expression Syntax

Question

Can I follow any simple syntax or rules for creating a “lambda expression” in C #? I read some articles and realized what a lambda expression is, but if I have a common syntax or rules that would be useful.

Answer 1

There are several ways to express lambda, depending on the exact scenario - some examples:

// simplest form; no types, no brackets Func<int, int> f1 = x => 2 * x; // optional exlicit argument brackets Func<int, int> f2 = (x) => 2 * x; // optional type specification when used with brackets Func<int, int> f3 = (int x) => 2 * x; // multiple arguments require brackets (types optional) Func<int, int, int> f4 = (x, y) => x * y; // multiple argument with explicit types Func<int, int, int> f5 = (int x, int y) => x * y; 

The lambda signature must match the signature of the delegate used (regardless of whether it is explicit, as indicated above, or implied by context in things like .Select(cust => cust.Name)

You can use lambdas with no arguments, using an empty list of expressions:

  // no arguments Func<int> f0 = () => 12; 

Ideally, the expression on the right is accurate; one expression. The compiler can convert this to a delegate or Expression tree:

  // expression tree Expression<Func<int, int, int>> f6 = (x, y) => x * y; 

However; you can also use statement blocks, but then they can only be used as delegate :

  // braces for a statement body Func<int, int, int> f7 = (x, y) => { int z = x * y; Console.WriteLine(z); return z; }; 

Note that even if the .NET 4.0 Expression trees support operator bodies, the C # 4.0 compiler does not execute for you, so you are still limited to simple Expression trees, unless you do it the "hard way"; see my article on InfoQ for more information.

Answer 2

A lambda expression, in essence, is an abbreviation for a function pointer. More often than not, a lambda expression is the propagation of input into an expression that evaluates the result. In most cases, you will use lambda expressions in their more common form:

 int[] numbers = new[] { 1, 3, 11, 21, 9, 23, 7, 4, 18, 7, 7, 3, 21 }; var twentyoneCount = numbers.Where(n => n == 21).Count(); var sumOfgreaterThanSeven = numbers.Sum(n => n > 7 ? n : 0); 

In its less common form, a lambda expression can replace the more bulky forms of delegates:

 myButton.Click += new EventHandler(myButton_Click); // ... void myButton_Click(object sender, EventArgs e) { // TODO: Implement button click handler here } 

Or less common and less verbose:

 myButton.Click += delegate(object sender, EventArgs e) { // TODO: Implement button click handler here }; 

The following lambda expression achieves the same result as the previous two:

 myButton.Click += (s,e) => { // TODO: Implement button click handler here }; 

The strength of this last form really comes from its ability to create closures. Closing is where you implement the function inside the function and "close" around the parameters and variables from the area of ​​the parent function:

 private void DoSomething(IList<string> input, SomeObject source) { source.OnSomeEvent += (s,e) => return input.Sum(); }