Expresión fluida y de consulta: ¿hay algún beneficio de uno sobre otro?

LINQ es una de las mejores mejoras para .NET desde generics y me ahorra muchísimo tiempo y líneas de código. Sin embargo, la syntax fluida parece ser mucho más natural para mí que la syntax de la expresión de consulta.

var title = entries.Where(e => e.Approved) .OrderBy(e => e.Rating).Select(e => e.Title) .FirstOrDefault(); var query = (from e in entries where e.Approved orderby e.Rating select e.Title).FirstOrDefault(); 

¿Hay alguna diferencia entre los dos o hay algún beneficio particular de uno sobre otro?

Ninguno de los dos es mejor: atienden necesidades diferentes. La syntax de consulta es independiente cuando desea aprovechar múltiples variables de rango . Esto sucede en tres situaciones:

  • Al usar la palabra clave let
  • Cuando tienes múltiples generadores ( de cláusulas)
  • Al hacer combinaciones

Aquí hay un ejemplo (de los ejemplos de LINQPad):

 string[] fullNames = { "Anne Williams", "John Fred Smith", "Sue Green" }; var query = from fullName in fullNames from name in fullName.Split() orderby fullName, name select name + " came from " + fullName; 

Ahora compare esto con lo mismo en la syntax del método:

 var query = fullNames .SelectMany (fName => fName.Split().Select (name => new { name, fName } )) .OrderBy (x => x.fName) .ThenBy (x => x.name) .Select (x => x.name + " came from " + x.fName); 

Sintaxis de método, por otro lado, expone toda la gama de operadores de consulta y es más conciso con consultas simples. Puede obtener lo mejor de ambos mundos mezclando syntax de consulta y método. Esto a menudo se hace en consultas LINQ to SQL:

 var query = from c in db.Customers let totalSpend = c.Purchases.Sum (p => p.Price) // Method syntax here where totalSpend > 1000 from p in c.Purchases select new { p.Description, totalSpend, c.Address.State }; 

Prefiero usar este último (a veces llamado “syntax de comprensión de consulta”) cuando puedo escribir toda la expresión de esa manera.

 var titlesQuery = from e in entries where e.Approved orderby e.Rating select e.Titles; var title = titlesQuery.FirstOrDefault(); 

Tan pronto como tengo que agregar (paréntesis) y .MethodCalls() , cambio.

Cuando uso el primero, suelo poner una cláusula por línea, como esta:

 var title = entries .Where (e => e.Approved) .OrderBy (e => e.Rating) .Select (e => e.Title) .FirstOrDefault(); 

Me parece un poco más fácil de leer.

Cada estilo tiene sus pros y sus contras. La syntax de consulta es más agradable cuando se trata de uniones y tiene la palabra clave let útil que facilita la creación de variables temporales dentro de una consulta.

La syntax fluida por otro lado tiene muchos más métodos y operaciones que no están expuestos a través de la syntax de la consulta. Además, dado que solo son métodos de extensión, puedes escribir los tuyos.

He descubierto que cada vez que empiezo a escribir una statement LINQ usando la syntax de la consulta, termino poniéndolo entre paréntesis y vuelvo a utilizar métodos de extensión LINQ con fluidez. La syntax de consulta simplemente no tiene suficientes funciones para usar por sí misma.

En VB.NET prefiero la syntax de consulta.

Odio repetir la fea Function -palabra clave:

 Dim fullNames = { "Anne Williams", "John Fred Smith", "Sue Green" }; Dim query = fullNames.SelectMany(Function(fName) fName.Split(). Select(Function(Name) New With {Name, fName})). OrderBy(Function(x) x.fName). ThenBy(Function(x) x.Name). Select(Function(x) x.Name & " came from " & x.fName) 

Esta consulta ordenada es mucho más legible y mantenible en mi opinión:

 query = From fullName In fullNames From name In fullName.Split() Order By fullName, name Select name & " came from " & fullName 

La syntax de consulta de VB.NET también es más potente y menos detallada que en C #: https://stackoverflow.com/a/6515130/284240

Por ejemplo, esta consulta LINQ a DataSet (Objetos)

VB.NET:

 Dim first10Rows = From r In dataTable1 Take 10 

DO#:

 var first10Rows = (from r in dataTable1.AsEnumerable() select r) .Take(10); 

No obtengo la syntax de consulta en absoluto. Simplemente no hay razón para eso en mi mente. let se puede lograr con. Seleccionar y tipos anónimos. Simplemente creo que las cosas se ven mucho más organizadas con la “puntuación” allí.

La interfaz fluida si hay solo un lugar. Si necesito seleccionar o ordenar, generalmente uso la syntax de consulta.

La syntax fluida parece ser más poderosa, también debería funcionar mejor para organizar el código en pequeños métodos reutilizables.

Sé que esta pregunta está etiquetada con C #, pero la syntax Fluent es tremendamente prolija con VB.NET.

Me gusta mucho la syntax Fluent y trato de usarla donde puedo, pero en ciertos casos, por ejemplo, cuando uso uniones, generalmente prefiero la syntax de Query, en esos casos me resulta más fácil de leer, y creo que algunas personas son más familiares para la syntax de Query (SQL), que lambdas.

Si bien entiendo y me gusta el formato fluido, me he quedado con Query por el momento por razones de legibilidad. Las personas que acaban de ser presentadas a LINQ encontrarán Query mucho más cómodo de leer.

Prefiero la syntax de consulta ya que vengo de la progtwigción web tradicional usando SQL. Es mucho más fácil para mí entender bien. Sin embargo, creo que comenzaré a utilizar el .Where (lambda) ya que definitivamente es mucho más corto.

He estado usando Linq durante aproximadamente 6 meses. Cuando comencé a usarlo, preferí la syntax de consulta, ya que es muy similar a T-SQL.

Pero, gradualmente estoy volviendo al primero ahora, ya que es fácil escribir fragmentos reutilizables de código como métodos de extensión y simplemente encadenarlos. Aunque encuentro que poner cada cláusula en su propia línea ayuda mucho con la legibilidad.

Acabo de establecer los estándares de nuestra compañía y hacemos cumplir el uso de los métodos de extensión. Creo que es una buena idea elegir uno sobre el otro y no mezclarlos en el código. Los métodos de extensión leen más como el otro código.

La syntax de comprensión no tiene todos los operadores y usa paréntesis alrededor de la consulta y agrega métodos de extensión después de que todo me suplica que use métodos de extensión desde el principio.

Pero en su mayor parte es solo preferencia personal con algunas excepciones.