C # Lambda expression learning notes

Here we will introduce the C # Lambda expression, which is actually no different from the anonymous method. Lambda's input parameters correspond to the parameters in the delegate brackets. Since C # Lambda expressions can infer the parameter type, the parameters here do not need to be declared.

 

C # is a common language. Here we mainly introduce C # Lambda expressions, including a Lambda expression as a delegate and a delegate pointing to a method.

 

Have you ever been familiar with C # Lambda expressions? Do you think the anonymous method is very good and it reduces a lot of code? But the use of anonymous methods is not human-oriented. What is human-oriented? For example, you can read the program code in a natural language. In. NET 2.0, the system. Collections. Generic namespace contains some new methods in the list. For example, find. How can we call an anonymous method:

 

 
 

  
  
books.Find(delegate(Book book){return book.Price < 50;}); 
 
 

The code is very simple, but it cannot be read out. Let's take a look at the C # Lambda expression:

 

Books. Find (Book => book. Price <50); this C # Lambda expression can be read as follows: to give you a book, if its price is less than 50, return true.

 

Well, let's go into the C # Lambda expression:

 

 

After the C # Lambda expression assembly is decompiled, we find that it is actually no different from the anonymous method. Lambda's input parameters correspond to the parameters in the delegate brackets. Since C # Lambda expressions can infer the parameter type, the parameters here do not need to be declared.

 

Lambda operators are read as "goes to", followed by expressions or statement blocks (this is also different from anonymous methods. Anonymous methods can only use statement blocks but not expressions ), the following example shows the types of C # Lambda expressions:

 

 
 

  
  
// The type of X is omitted. the compiler can deduce it based on the context, followed by an expression.
  
  
X =>X + 1
  
  
Deleage (int x) {return x + 1 ;}
  
  
// The block is followed by the statement Block
  
  
X =>{Return x + 1 ;}
  
  
Delegate (int x) {return x + 1 ;}
  
  
// The input parameter can also contain the type. Do not forget the parentheses after the type.
  
  
(Int x) =>X + 1
  
  
Delegate (int x) {return x + 1 ;}
  
  
// You can also enter multiple parameters separated by commas (,). Do not forget parentheses.
  
  
(X, y) =>X + Y
  
  
Delegate (int x, int y) {return X + Y ;}
  
  
// No parameters are returned.
  
  
 
  
  
() =>1
  
  
 
  
  
Delegate () {return 1 ;}
 
 

This is the way C # Lambda expressions are used, but there are many stories and mysteries behind lambda. The C # Lambda expression can be used to construct an Expression Tree, and the expression tree is as important as the root of the tree for the LINQ clause. We will not discuss the expression tree here. This is not something that can be clearly stated in a few words. We will discuss it further when the time is ripe.

 

C # Read more about lambda expressions

 

Lambda actually has a long history. The machines we use today are from the Von noriman system and belong to the Turing Machine. Before that, there was another theory called the lambda algorithm, but the Turing machine was first implemented, as a result, the lambda algorithm became a functional programming language, especially lisp. In functional programming languages, functions were the first element, function parameters, and function return values were all functions, the program has no variables and functions are nested. Functional programming languages have always existed in the ivory tower, so they are not widely used in the industry. However, in recent years, the industry prefers the "Retro" style, therefore, functional programming languages are slowly taking the stage of history. Functional programming can solve some imperative Programming Problems (or it is very troublesome to solve ). C # What should I do with function-style programming? The method defined by the original method is definitely not feasible. 2.0 of anonymous methods solve this problem in a program, but it is still not enough, lambda in 3.0 has finally been well solved. A Lambda is a delegate, and a delegate points to a method. Now we can simply pass the method as a parameter using lambda, layers can also be nested, which is very simple.