262 votes

LINQ - Courant et d'Expression de Requête - Est-il un avantage(s) de l'un sur l'autre?

LINQ est l'une des plus grandes améliorations .NET puisque les génériques et il me sauve des tonnes de temps et de lignes de code. Toutefois, la fluidité de la syntaxe semble beaucoup plus naturel pour moi que la syntaxe d'expression de requête.

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();

Quelle est la différence entre les deux ou est-il un avantage particulier de l'un sur l'autre?

264voto

Joe Albahari Points 13644

Il n'est ni mieux: ils répondent à différents besoins. La syntaxe de la requête vient dans son propre lorsque vous voulez bénéficier de multiples variables de portée. Ce qui se passe dans trois situations:

  • Lorsque vous utilisez le mot-clé let
  • Lorsque vous avez plusieurs générateurs (de clauses)
  • Quand vous faites des jointures

Voici un exemple (à partir de la LINQPad échantillons):

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;

Maintenant comparez cela à la même chose dans la méthode de la syntaxe:

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 syntaxe de méthode, d'autre part, expose l'ensemble des opérateurs de requête et est plus concis avec des requêtes simples. Vous pouvez obtenir le meilleur des deux mondes en mélangeant de la requête et de la méthode de la syntaxe. Cela est souvent fait dans LINQ to SQL des requêtes:

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 };

58voto

Jay Bazuzi Points 20462

Je préfère utiliser ce dernier (parfois appelée "requête de compréhension de la syntaxe") quand je peux écrire la totalité de l'expression de cette façon.

var titlesQuery = from e in entries
                  where e.Approved
                  orderby e.Rating
                  select e.Titles;

var title = titlesQuery.FirstOrDefault();

Dès que j'ai à ajouter (entre parenthèses) et .MethodCalls(), je change.

Lorsque j'utilise l'ancienne, j'ai l'habitude de mettre une clause par ligne, comme ceci:

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

Je trouve qu'un peu plus facile à lire.

29voto

James Newton-King Points 13880

Chaque style a ses avantages et ses inconvénients. La syntaxe de la requête est plus agréable quand il s'agit de la rejoint et il est utile de laisser mot clé qui permet de créer des variables temporaires à l'intérieur d'une requête simple.

Couramment syntaxe de l'autre main a beaucoup plus de méthodes et opérations qui ne sont pas exposés à travers la syntaxe de la requête. Aussi, depuis qu'ils sont tout simplement des méthodes d'extension, vous pouvez écrire votre propre.

J'ai constaté que chaque fois que je démarre l'écriture d'un LINQ déclaration à l'aide de la syntaxe de la requête, je finis par avoir à le mettre dans la parenthèse et revenir à l'utilisation d'couramment LINQ méthodes d'extension. La syntaxe de la requête n'a tout simplement pas assez de fonctionnalités pour une utilisation par lui-même.

23voto

Tim Schmelter Points 163781

Parce que je suis essentiellement un VB.NET développeur, je suis absolument en préférant la syntaxe de la requête.

Je déteste répéter le laid Function-mot-clé:

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)

Cette soigné requête est beaucoup plus lisible et maintenable à mon avis:

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

VB.NET'la syntaxe de la requête est également plus puissant et moins verbeux que en C#: http://stackoverflow.com/a/6515130/284240

Par exemple cette LINQ to DataSet(Objets) de la requête

VB.NET:

Dim first10Rows = From r In dataTable1 Take 10

C#:

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

13voto

James Curran Points 55356

L'interface fluide s'il y a une où la. Si j'ai besoin de sélectionner ou orderby, j'utilise généralement la syntaxe de la Requête.

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X