query - linq c# tutorial español

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

Question

LINQ es una de las mejoras más grandes para .NET desde genéricos y me ahorra mucho tiempo y líneas de código. Sin embargo, la sintaxis fluida me parece mucho más natural que la sintaxis de 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?

Answer 1

Acabo de configurar los estándares de nuestra empresa y aplicamos el uso de los métodos de Extensión. Creo que es una buena idea elegir una sobre la otra y no mezclarlas con el código. Los métodos de extensión se leen más como el otro código.

La sintaxis de comprensión no tiene todos los operadores y el uso de paréntesis alrededor de la consulta y agregar métodos de extensión, después de todo, solo me suplica que use métodos de extensión desde el principio.

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

Answer 2

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

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

He descubierto que cada vez que empiezo a escribir una declaración LINQ utilizando la sintaxis de consulta, tengo que ponerla entre paréntesis y volver a utilizar métodos de extensión LINQ fluidos. La sintaxis de consulta simplemente no tiene suficientes funciones para usar por sí misma.

Answer 3

En VB.NET prefiero mucho la sintaxis de consulta.

Odio repetir la fea Function -keyword:

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 clara consulta 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 sintaxis de consulta de VB.NET también es más potente y menos detallada que en C #: https://.com/a/6515130/284240

Por ejemplo, esta consulta LINQ to DataSet (Objetos)

VB.NET:

Dim first10Rows = From r In dataTable1 Take 10

DO#:

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

Answer 4

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

Pero ahora voy gradualmente al primero, ya que es fácil escribir fragmentos de código reutilizables 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.

Answer 5

La interfaz fluida si solo hay un dónde. Si necesito una selección o un pedido, generalmente uso la sintaxis de consulta.

Answer 6

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

Answer 7

No obtengo la sintaxis de consulta en absoluto. Simplemente no hay razón para ello en mi mente. Let puede ser logrado con .Select y tipos anónimos. Simplemente creo que las cosas se ven mucho más organizadas con la "puntuación" ahí.

Answer 8

Prefiero la sintaxis de consulta, ya que provengo de la programación web tradicional usando SQL. Es mucho más fácil para mí envolver mi cabeza. Sin embargo, creo que comenzaré a utilizar .Where (lambda) ya que es definitivamente mucho más corto.

Answer 9

Prefiero usar la última (a veces llamada "sintaxis de comprensión de consulta") cuando puedo escribir la expresión completa 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, normalmente pongo 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.

Answer 10

Realmente me gusta la sintaxis Fluent y trato de usarla donde puedo, pero en ciertos casos, por ejemplo, cuando uso uniones, generalmente prefiero la sintaxis Query, en esos casos me resulta más fácil de leer y creo que algunas personas Son más familiares a la sintaxis de consulta (similar a SQL) que las lambdas.

Answer 11

Sé que esta pregunta está etiquetada con C #, pero la sintaxis de Fluent es dolorosamente detallada con VB.NET.

Answer 12

Si bien entiendo y me gusta el formato fluido, por el momento me he limitado a Query por razones de legibilidad. La gente que acaba de ser introducida a LINQ encontrará a Query mucho más cómodo para leer.

Answer 13

Tampoco es mejor: atienden a diferentes necesidades. La sintaxis de las consultas es única cuando se quiere aprovechar varias variables de rango . Esto sucede en tres situaciones:

• Al usar la palabra clave let
• Cuando tienes múltiples generadores ( de cláusulas)
• Cuando se hacen juntas

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 la misma sintaxis de 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);

La sintaxis del método, por otro lado, expone la gama completa de operadores de consulta y es más concisa con consultas simples. Puede obtener lo mejor de ambos mundos combinando la sintaxis de consulta y método. Esto se hace a menudo en las 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 };