Explique x => x.ToString() //simplifique tantas chamadas

Question

Em um Resposta da questão Encontro a seguinte dica de codificação: -

2) lambdas simples com um parâmetro:

x => x.ToString() //simplify so many calls

Como alguém que ainda não usou o 3.0, eu realmente não entendo essa dica, mas parece interessante, então eu apreciaria uma expansão sobre como isso simplifica as chamadas com alguns exemplos.

Eu pesquisei lambdas então eu pensar Eu sei o que eles fazem, mas eu poderia não entendo completamente, então um pequeno desembalar também pode estar em ordem.

Answer 1

Quando você precisa criar uma instância de um delegado que possui um único parâmetro, as expressões lambda permitem criar esse delegado "inline" de uma maneira muito concisa.Por exemplo, aqui está o código para encontrar uma pessoa específica em uma lista, pelo nome:

List<Person> list = new List<Person>();
// [..] Populate list here
Person jon = list.Find(p => p.Name == "Jon");

No C# 2.0 você poderia usar um método anônimo que fosse um pouco mais demorado, mas não também ruim:

List<Person> list = new List<Person>();
// [..] Populate list here
Person jon = list.Find(delegate(Person p) { return p.Name == "Jon"; });

No C# 1.0 você teria que criar todo um método extra.Além disso, se você quisesse parametrizá-lo, teria que criar um tipo diferente, enquanto métodos anônimos e expressões lambda capturam seu ambiente de execução (variáveis ​​locais, etc.), para que atuem como fechamentos:

public Person FindByName(List<Person> list, String name)
{
    return list.Find(p => p.Name == name); // The "name" variable is captured
}

Há mais sobre isso em meu artigo sobre fechamentos.

Embora passar delegados para métodos não seja muito comum no C# 2.0 e no .NET 2.0, é uma grande parte da base do LINQ - portanto, você tende a usá-lo muito no C# 3.0 com o .NET 3.5.

Answer 2

Isso basicamente se expande para:

private string Lambda(object x) {
  return x.ToString();
}

Answer 3

Você está familiarizado com os métodos anônimos C# 2.0? Essas duas chamadas são equivalentes (assumindo que um modelo aceite um delegado etc.):

SomeMethod(x => x.ToString());

SomeMethod(delegate (SomeType x) { return x.ToString();});

Eu sei qual prefiro digitar ...

Answer 4

string delegate(TypeOfX x)
{
  return x.ToString();
}