Expression fluide et Requête-y a-t-il des avantages de l'un par rapport à l'autre?
LINQ est L'une des plus grandes améliorations de.Net depuis les génériques et cela me permet d'économiser des tonnes de temps et de lignes de code. Cependant, la syntaxe fluide me semble beaucoup plus naturelle 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?
13 réponses
Ni l'un ni l'autre n'est meilleur: ils servent des besoins différents. La syntaxe de requête prend tout son sens lorsque vous souhaitez exploiter plusieurs variables de plage . Cela se produit dans trois situations:
- lors de l'utilisation du mot-clé let
- Lorsque vous avez plusieurs générateurs (à partir de clauses)
- lors des jointures
Voici un exemple (à partir des échantillons 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;
Maintenant, comparez cela à la même chose dans la syntaxe de la méthode:
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);
Syntaxe de la méthode, sur le 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 la syntaxe de requête et de méthode. Cela se fait souvent dans les requêtes 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 };
Je préfère utiliser ce dernier (parfois appelé "syntaxe de compréhension de requête") quand je peux écrire l'expression entière 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 je dois ajouter (parenthèses) et .MethodCalls(), je change.
Quand j'utilise le premier, je mets habituellement une clause par ligne, comme ceci:
var title = entries
.Where (e => e.Approved)
.OrderBy (e => e.Rating)
.Select (e => e.Title)
.FirstOrDefault();
Je trouve cela un peu plus facile à lire.
Chaque style a ses avantages et ses inconvénients. La syntaxe de requête est plus agréable quand il s'agit de jointures et elle a le mot-clé let utile qui facilite la création de variables temporaires dans une requête.
Syntaxe fluide d'autre part a beaucoup plus de méthodes et d'opérations qui ne sont pas exposées via la syntaxe de la requête. Aussi, puisqu'ils ne sont que des méthodes d'extension, vous pouvez écrire les vôtres.
J'ai trouvé que chaque fois que je commence à écrire une instruction LINQ en utilisant la syntaxe de requête, je finis par avoir pour le mettre entre parenthèses et revenir à l'utilisation de méthodes d'extension LINQ fluent. La syntaxe de requête n'a tout simplement pas assez de fonctionnalités à utiliser par elle-même.
Dans VB.NET je préfère beaucoup la syntaxe de 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 requête soignée 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 requête est également plus puissante et moins verbeuse qu'en C#: https://stackoverflow.com/a/6515130/284240
Par exemple, cette requête LINQ to DataSet (Objects)
VB.NET:
Dim first10Rows = From r In dataTable1 Take 10
C#:
var first10Rows = (from r in dataTable1.AsEnumerable()
select r)
.Take(10);
Je n'obtiens pas du tout la syntaxe de la requête. Il n'y a juste aucune raison à cela dans mon esprit. laissez peut être acheived avec .Sélectionnez et types anonymes. Je pense juste que les choses semblent beaucoup plus organisées avec la "ponctuation" là-dedans.
L'interface fluide s'il y a juste un où. Si j'ai besoin d'un select ou d'un orderby, j'utilise généralement la syntaxe de requête.
La syntaxe fluide semble en effet plus puissante, elle devrait également mieux fonctionner pour organiser le code en petites méthodes réutilisables.
Je sais que cette question est étiquetée avec C#, mais la syntaxe fluide est douloureusement verbeuse avec VB.NET.
J'aime vraiment la syntaxe fluide et j'essaie de l'utiliser où je peux, mais dans certains cas, par exemple lorsque j'utilise des jointures, je préfère généralement la syntaxe de requête, dans ces cas je la trouve plus facile à lire, et je pense que certaines personnes sont plus familières à la syntaxe de requête (SQL-like), que lambdas.
Bien que je comprenne et aime le format fluide , je suis resté à interroger pour le moment pour des raisons de lisibilité. Les gens qui viennent d'être présentés à LINQ trouveront Query beaucoup plus confortable à lire.
Je préfère la syntaxe de requête car je viens de la programmation web traditionnelle en utilisant SQL. Il est beaucoup plus facile pour moi d'envelopper ma tête. Cependant, il pense que je vais commencer à utiliser le .Où (lambda) car il est certainement beaucoup plus courte.
J'utilise Linq depuis environ 6 mois maintenant. Quand j'ai commencé à l'utiliser, j'ai préféré la syntaxe de requête car elle est très similaire à T-SQL.
Mais, je reviens progressivement à l'ancien maintenant, car il est facile d'écrire des morceaux de code réutilisables en tant que méthodes d'extension et de les chaîner ensemble. Bien que je trouve que mettre chaque clause sur sa propre ligne aide beaucoup avec la lisibilité.
Je viens de mettre en place les normes de notre entreprise et nous appliquons l'utilisation des méthodes D'Extension. Je pense que c'est une bonne idée de choisir l'un sur l'autre et ne pas les mélanger dans le code. Méthodes d'Extension lire plus comme l'autre code.
La syntaxe de compréhension n'a pas tous les opérateurs et l'utilisation de parenthèses autour de la requête et ajouter des méthodes d'extension après tout me supplie d'utiliser des méthodes d'extension dès le début.
, Mais pour la plupart, c'est juste une préférence personnelle avec à quelques exceptions près.