Vanaf C# 2.0 kon je gebruik maken van anonieme methoden om (soms onnodig omslachtige) delegate-instructies te vervangen.
Lambda expressies voorzien in een meer compacte, consistente manier om anonieme methoden te schrijven. Ze zijn bijzonder handig bij het werken met Linq-expressies.

• Maak een klasse Person:

  public class Person {
          public string FirstName { get; set; }
          public string LastName  { get; set; }        
          public int    Age       { get; set; }
  }
  

• Maak in een Console-Toepassing een collectie people:

  static void Main(string[] args)
  {
  	List<Person> people = new List<Person> {
     		new Person { FirstName = "William", LastName = "Schokkele", Age = 35 },
     		new Person { FirstName = "Bill", LastName = "Gates", Age = 50 },
     		new Person { FirstName = "Hanne", LastName = "Schokkele", Age = 7 }
  	};
  }
  

• Voorzie volgende Linq-queries:

  IEnumerable personen;
  
  personen = people.Where(p => p.LastName == "Schokkele");
  double gemiddeldeLeeftdijd = people.Average(p => p.Age);
  int hoogsteLeeftijd = people.Max(p => p.Age);
  
  foreach (Person p in personen)
  {
  	Console.WriteLine(p.FirstName +" " + p.LastName);
  }
  Console.WriteLine("Gemiddelde leeftijd: " +gemiddeldeLeeftdijd.ToString());
  Console.WriteLine("Hoogste leeftijd: " + hoogsteLeeftijd.ToString());
  

  De p => -uitdrukkingen in bovenstaande voorbeelden noemen we lambda-expressies.

  De eenvoudigste manier om lambda-expressies te begrijpen is ze gewoon te zien als anonieme methoden:

  personen = people.Where(
                             delegate(Person p)
                             {
                                 return p.LastName == "Schokkele";
                             }
                          );
  
  double gemiddeldeLeeftdijd = people.Average(
                                                delegate(Person p)
                                                {
                                                   return p.Age;
                                                }
                                              );
  
  
  

  Beide anonieme methoden ontvangen een object van het type Person als parameter.
  De eerste methode retourneert een bool, de tweede een int.
  De twee equivalente lambda-expressies doen hetzelfde, ze ontvangen een Person-object, de ene retourneert een bool, de andere een string.

  In C# wordt een lambda-expressie geschreven als een parameterlijst gevolgd door => gevolgd door het statement of codeblok dat moet uitgevoerd worden.

  parameters => expressie
  

  Wanneer we dus hetvolgende schreven:

  p => p.LastName == "Schokkele"
  

  Gaven we aan dat de lambda die we definiëerden een parameter "p" ontving en dat de code die zal uitgevoerd worden retourneert of de eigenschap LastName van p gelijk is aan "Schokkele".
  Het feit dat we de parameter "p" noemen is irrelevant, het kon net zo goed "x", "y" of "zorro" zijn.

  Anonieme methode vereisen dat het type van de parameter(s) vooraf bekend wordt gemaakt, bij lambda-expressies is dit niet zo, het type kan afgeleid worden uit het gebruik.
  Bij het uitvoeren van de lambda-expressie kon de compiler uitmaken dat "p" een Person is doordat de extension method Where werkte op een List<Person> collectie.

  Het leukste is dat Visual Studio zelfs design-time het type kan afleiden en dus "p" voorziet van Intellisense.

  Als je wil kan je expliciet het type van de parameter aangeven:

  personen = people.Where((Person p) => p.LastName == "Schokkele");