c# - operaciones - LINQ-Sintaxis de consulta vs cadenas de métodos y lambda

linq select all

Question

¿Alguien se atiene a las reglas (o está obligado a cumplir con las reglas de su empleador?) Cuando elige usar la sintaxis de consulta LINQ o una expresión Lambda dentro de uno de los métodos de extensión LINQ? Esto se aplica a cualquier Entidad, SQL, Objetos, cualquier cosa.

En nuestro lugar de trabajo, a mi jefe no le gusta lambda en absoluto y utilizaría la sintaxis de consulta para cualquier cosa, que en algunos casos, considero que son menos legibles.

var names = collection.Select(item => item.Name);

var names = from item in collection
            select item.Name;

Tal vez cuando agrego una condición, la Lambda que encuentro se vuelve un poco desordenada, donde el

var names = collection.Where(item => item.Name == "Fred")
                      .Select(item => item.Name);

var names = from item in collection
            where item.Name == "Fred"
            select item.Name;

Solo por interés: ¿cómo trata el compilador este? ¿Alguien sabe cómo la consulta LINQ anterior se compilará en lambda? ¿Se llamará a la propiedad Name para cada elemento? ¿Podríamos hacer esto y posiblemente mejorar el rendimiento? ¿Esto significa que lambda es un poco más controlable en términos de rendimiento?

var names = collection.Select(item => item.Name)
                      .Where(name => name == "Fred");

Ciertamente, cuando comenzamos a usar más y más expresiones, la lambda se vuelve desordenada y comenzaría a usar la sintaxis de la consulta aquí.

var names = collection.Where(item => item.Name == "Fred")
                      .OrderBy(item => item.Age)
                      .Select(item => item.Name);

var names = from item in collection
            where item.Name == "Fred"
            order by item.Age
            select item.Name;

También hay algunas cosas que encuentro que no se pueden hacer con la sintaxis de la consulta. Algunos de ellos pensarían que serían realmente simples (particularmente funciones agregadas), pero no, deben agregar uno de los métodos de extensión LINQ hasta el final, que imo, se ve más ordenado con una expresión lambda.

var names = collection.Count(item => item.Name == "Fred");

var names = (from item in collection
            where item.Name == "Fred"
            select item).Count()

Incluso para algunas de las cadenas lambda simples, ReSharper sugiere que las convierta en consultas de LINQ.

¿Alguien más puede agregar a esto? ¿Alguien tiene sus propias pequeñas reglas o su compañía sugiere / fuerza el uso de una?

Answer 1

Para responder a su pregunta sobre la traducción, la expresión de consulta siempre se traducirá según las reglas en 7.16 de la especificación C # 4 (o su equivalente en la especificación C # 3). En el ejemplo en el que hace la pregunta sobre la propiedad Name , no se trata de la traducción de la expresión de consulta, es lo que hacen los métodos Select y Where con los delegados o los árboles de expresión que toman como parámetros. A veces tiene sentido hacer una proyección antes de filtrar, a veces no.

En cuanto a las reglas pequeñas, solo tengo una: use la que sea más legible para la consulta en cuestión. Entonces, si la consulta cambia y "qué forma es más legible" cambia al mismo tiempo, cambie la sintaxis utilizada.

Si vas a utilizar LINQ, deberías contentarte con la sintaxis, por lo menos para leer.

SelectMany a encontrar que las consultas con múltiples variables de rango (por ejemplo, mediante SelectMany o Join , o una cláusula let ) terminan siendo más legibles usando expresiones de consulta, pero eso está lejos de ser una regla difícil y rápida.