Explica x = > x.ToString () // simplifica tantas llamadas

Question

En una pregunta respuesta encuentro la siguiente sugerencia de codificación: -

2) lambdas simples con un parámetro:

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

Como alguien que aún no ha usado 3.0, no entiendo realmente este consejo, pero parece interesante, por lo que agradecería una explicación de cómo esto simplifica las llamadas con algunos ejemplos.

He investigado lambdas, así que pienso Sé lo que hacen, sin embargo, puede no entender completamente, por lo que un poco también podría desempaquetar estar en orden.

Answer 1

Cuando necesita crear una instancia de un delegado que tenga un solo parámetro, las expresiones lambda le permiten crear ese delegado " en línea " de una manera muy concisa. Por ejemplo, aquí hay un código para encontrar a una persona en particular en una lista, por su nombre:

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

En C # 2.0, puedes usar un método anónimo que es un poco más lento, pero no también malo:

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

En C # 1.0 tendrías que crear un método extra completo. Además, si quisiera parametrizarlo, tendría que crear un tipo diferente, mientras que los métodos anónimos y las expresiones lambda capturan su entorno de ejecución (variables locales, etc.) para que actúen como cierres:

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

Hay más información sobre esto en mi artículo sobre cierres .

Aunque pasar delegados a métodos no es terriblemente común en C # 2.0 y .NET 2.0, es una gran parte de la base de LINQ, por lo que tiende a usarlo mucho en C # 3.0 con .NET 3.5.

Answer 2

Esto básicamente se expande a:

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

Answer 3

¿Está familiarizado con los métodos anónimos de C # 2.0? Estas dos llamadas son equivalentes (suponiendo que SomeMethod acepte un delegado, etc.):

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

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

Sé que prefiero escribir ...

Answer 4

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