c# - lista - Código equivalente a la palabra clave ''let'' en llamadas de método de extensión LINQ encadenadas

update item in list c#

Question

Usando las características de comprensión de consulta de los compiladores C #, puedes escribir código como:

var names = new string[] { "Dog", "Cat", "Giraffe", "Monkey", "Tortoise" };
var result =
    from animalName in names
    let nameLength = animalName.Length
    where nameLength > 3
    orderby nameLength
    select animalName; 

En la expresión de consulta anterior, la palabra clave let permite let un valor a las operaciones where y orderby sin llamadas duplicadas a animalName.Length .

¿Cuál es el conjunto equivalente de llamadas al método de extensión LINQ que logra lo que la palabra clave "let" hace aquí?

Answer 1

Hay un buen artículo here

Esencialmente let crea una tupla anónima. Es equivalente a:

var result = names.Select(
  animal => new { animal = animal, nameLength = animal.Length })
.Where(x => x.nameLength > 3)
.OrderBy(y => y.nameLength)
.Select(z => z.animal);

Answer 2

Let no tiene su propia operación; se retrae de Select . Puedes ver esto si usas "reflector" para separar una dll existente.

será algo así como:

var result = names
        .Select(animalName => new { nameLength = animalName.Length, animalName})
        .Where(x=>x.nameLength > 3)
        .OrderBy(x=>x.nameLength)
        .Select(x=>x.animalName);

Answer 3

También hay un método de extensión .Let en System.Interactive, pero su propósito es introducir una expresión lambda para ser evaluada ''en línea'' en una expresión fluida. Por ejemplo, considere (en LinqPad, por ejemplo) la siguiente expresión que crea nuevos números aleatorios cada vez que se ejecuta:

var seq = EnumerableEx.Generate(
    new Random(),
    _ => true,
    _ => _,
    x => x.Next());

Para ver que nuevas muestras aleatorias aparecen cada vez, considere lo siguiente

seq.Zip(seq, Tuple.Create).Take(3).Dump();

que produce pares en los que la izquierda y la derecha son diferentes. Para producir pares en los que la izquierda y la derecha son siempre las mismas, haga algo como lo siguiente:

seq.Take(3).ToList().Let(xs => xs.Zip(xs, Tuple.Create)).Dump(); 

Si pudiéramos invocar expresiones lambda directamente, podríamos escribir

(xs => xs.Zip(xs, Tuple.Create))(seq.Take(3).ToList()).Dump();

Pero no podemos invocar expresiones lambda como si fueran métodos.