linq "let" translation

Question

Entiendo que cuando el compilador de C# ve un linq query comprehension, básicamente hace una traducción directa a los métodos de extensión Linq correspondientes y lambdas. es decir,

from x in list 
select x.property 

se traduce a:

list.Select(x => x.property) 

mi pregunta es: ¿qué let cláusulas se traducen a. por ejemplo, cómo sería traducido esto por el compilador.

from x in list 
let v = SomeComplexExpressionDependingOnx 
select v 

(P. S. sé que esto podría reducirse a solo select SomeComplexExpressionDependingOnx pero quiero saber cómo se hace esto en general)

Gracias!

Answer 1

En este caso particular, se traduce a:

list.Select(x => SomeComplexExpressionDependingOnx); 

Pero puede haber un caso más complejo, como por ejemplo:

from x in list 
let v = SomeComplexExpressionDependingOnx 
where v > 10 && v+5 < 50 && SomeFunc(v) == "str" 
select x 

se traducirá en:

list.Where(x => 
    { 
     var v = SomeComplexExpressionDependingOnx; 
     return v > 10 && v+5 < 50 && SomeFunc(v) == "str"; 
    } 
) 

En otras palabras, la palabra clave let es una forma de minimizar y/u optimizar su consulta. Es decir, sin la palabra clave let que tendría que escribir:

from x in list 
where 
    SomeComplexExpressionDependingOnx > 10 && 
    SomeComplexExpressionDependingOnx+5 < 50 && 
    SomFunc(SomeComplexExpressionDependingOnx) == "str" 
select x 

resultando en una posible evaluación de triple de la misma expresión.

Actualización, a raíz de una pregunta en el comentario.

Primero, ¿qué tiene de atemorizante "expresiones de bloque"? Son solo una abreviatura de delegado arbitrario. Es decir, la siguiente expresión:

Func<string,int> f = 
    s => 
    { 
     var ln = s.Length; 
     return ln/2; 
    } 

es equivalente a lo siguiente:

int CompilerGeneratedMethodIdentifier0(string s) 
{ 
    var ln = s.Length; 
    return ln/2; 
} 

... 

Func<string, int> f = new Func<string, int>(CompilerGeneratedMethodIdentifier0); 

Segunda, lo que es tan especial sobre las expresiones "bloquear"? ¿Sabías que mmm ...llamémosles "sin bloque" ¿las expresiones también se expanden al mismo código? Es decir, el código simple new Func<string,int>(s => s.Length/2) es equivalente a absoluta:

int CompilerGeneratedMethodIdentifier0(string s) 
{ 
    return s.Length/2; 
} 

... 

new Func<string, int>(CompilerGeneratedMethodIdentifier0); 

Tercer, lo que es tan no linqy sobre las expresiones "bloquear"? LINQ usa delegados por todas partes, y realmente no le importa a LINQ qué atajo exacto utilizas para representar a esos delegados.

En particular, su expresión from a in list where a.SomeProp > 10 select new { A = a, B = a.GetB() } se traduce en lo siguiente:

class AnonymousType0 
{ 
    public MyClass A { get; set; } 
    public othertype B { get; set; } 
} 

bool WhereFunc0(MyClass a) 
{ 
    return a.SomeProp > 10; 
} 

AnonymousType0 SelectResultFunc0(MyClass a) 
{ 
    AnonymousType0 result = new AnonymousType0(); 
    result.A = a; 
    result.B = a.GetB(); 
    return result; 
} 

... 

list 
    .Where(new Func<MyClass,bool>(WhereFunc0)) 
    .Select(new Func<MyClass,AnonymousType0>(SelectResultFunc0)); 

Cuarta, para obtener la comprensión de esta manera, uno puede jugar con el lenguaje y pensar. Usa tu cerebro, eso es.

Y quinto, si el consejo anterior no funciona para usted por una razón u otra, siempre tiene ILSpy. Herramienta muy útil, todo el mundo debería tener una.

Answer 2

Sólo una conjetura ya que rara vez usar la sintaxis de consulta:

list.Select(x => new { v = SomeComplexExpressionDependingOnx(x) }); 

El let es simplemente la asignación de una nueva var v el Select es devolverlo.

También podría ser el siguiente si no desea que un objeto anon con v en ella:

var v = list.Select(x => SomeComplexExpressionDependingOnx(x)); 

Answer 3

list.Select(x => SomeComplexExpressionDependingOnx); 

En general, let básicamente funciona como una variable readonly la celebración de un rango.

Answer 4

Eche un vistazo a LINQPad, puede escribir la consulta y presionar el símbolo lamba para ver cómo se verá la salida. Por ejemplo Tomé esta consulta:

var names = new[] { "Tom", "Dick", "Harry", "Mary", "Jay" }.AsQueryable(); 

var results = 
    from n in names 
    let n1 = String.IsNullOrEmpty(n) 
    select n1; 

results.Dump(); 

Y salida de los siguientes:

System.String[] 
    .Select (
     n => 
     new 
     { 
      n = n, 
      n1 = String.IsNullOrEmpty (n) 
     } 
    ) 
    .Select (temp0 => temp0.n1) 

Por lo tanto, sí que parece que la let se traduce en un valor de temperatura tan anónimo, y luego se consume en el exterior Seleccionar instrucción.

Me encanta LINQPad por la capacidad de escribir la consulta y ver cómo se traduciría.