Беглое выражение и выражение запросов - есть ли преимущества одного перед другим?

Плавный синтаксис действительно кажется более мощным, он также должен работать лучше для организации кода в небольшие многократно используемые методы.

Свободный интерфейс, если есть только где. Если мне нужен select или orderby, я обычно использую синтаксис запроса.

Мне очень нравится синтаксис Fluent, и я стараюсь использовать его там, где могу, но в некоторых случаях, например, когда я использую объединения, я обычно предпочитаю синтаксис запросов, в этих случаях мне легче читать, и я думаю, что некоторые люди синтаксис запросов (похожий на SQL) более знаком, чем лямбды.

Хотя я понимаю и люблю свободный формат, я пока придерживаюсь Query из соображений удобочитаемости. Людям, только знакомым с LINQ, будет намного удобнее читать Query.

У каждого стиля есть свои плюсы и минусы. Синтаксис запроса лучше, когда дело доходит до объединений, и в нем есть полезное ключевое слово позволять, которое упрощает создание временных переменных внутри запроса.

С другой стороны, свободный синтаксис имеет гораздо больше методов и операций, которые не отображаются через синтаксис запроса. Кроме того, поскольку это просто методы расширения, вы можете написать свои собственные.

Я обнаружил, что каждый раз, когда я начинаю писать оператор LINQ с использованием синтаксиса запроса, мне приходится заключать его в круглые скобки и возвращаться к использованию свободных методов расширения LINQ. Синтаксис запроса просто не имеет достаточного количества функций, чтобы использовать его самостоятельно.

Я предпочитаю использовать последнее (иногда называемое «синтаксисом понимания запроса»), когда я могу написать таким образом все выражение.

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

var title = titlesQuery.FirstOrDefault();

Как только мне нужно добавить (скобки) и .MethodCalls(), я меняю.

Когда я использую первое, я обычно помещаю по одному предложению в строку, например:

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

Я считаю, что это немного легче читать.

Я предпочитаю синтаксис запросов, поскольку я пришел из традиционного веб-программирования с использованием SQL. Мне намного легче обдумать. Тем не менее, я думаю, что начну использовать .Where (лямбда), поскольку он определенно намного короче.

Я вообще не понимаю синтаксиса запроса. По-моему, для этого просто нет причин. let может быть достигнута с .Select и анонимными типами. Я просто думаю, что с «пунктуацией» все выглядит намного организованнее.

Пользуюсь Linq уже около 6 месяцев. Когда я впервые начал его использовать, я предпочел синтаксис запроса, так как он очень похож на T-SQL.

Но сейчас я постепенно перехожу к первому, так как легко написать многоразовые фрагменты кода как методы расширения и просто связать их вместе. Хотя я считаю, что размещение каждого предложения в отдельной строке очень помогает с удобочитаемостью.

Ни то, ни другое не лучше: они служат различным потребностям. Синтаксис запроса приходит на помощь, когда вы хотите использовать несколько переменных диапазона. Это происходит в трех ситуациях:

• При использовании ключевого слова let
• Когда у вас несколько генераторов (предложения из)
• При выполнении присоединяется

Вот пример (из примеров 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;

Теперь сравните это с тем же синтаксисом метода:

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

С другой стороны, синтаксис метода предоставляет полный спектр операторов запроса и более краток для простых запросов. Вы можете получить лучшее из обоих миров, смешивая синтаксис запроса и метода. Это часто делается в запросах 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 };

Я знаю, что этот вопрос помечен тегом C#, но синтаксис Fluent мучительно многословен с VB.NET.

Я только что установил стандарты нашей компании, и мы настаиваем на использовании методов расширения. Я думаю, что лучше выбрать одно из них и не путать их в коде. Методы расширения больше похожи на другой код.

Синтаксис понимания не имеет всех операторов, и использование круглых скобок вокруг запроса и добавления методов расширения в конце концов просто напрашивает меня на использование методов расширения с самого начала.

Но по большей части это личные предпочтения, за некоторыми исключениями.

В VB.NET я очень предпочитаю синтаксис запроса.

Ненавижу повторять уродливое ключевое слово Function:

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)

На мой взгляд, этот аккуратный запрос более читабелен и удобен в обслуживании:

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

Синтаксис запросов VB.NET также более мощный и менее подробный, чем в C#: https://stackoverflow.com/a/6515130/284240

Например, этот запрос 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);