Чи має значення порядок функцій LINQ?

В основному, як зазначено в питанні ... чи має значення порядок функцій LINQ щодо продуктивності ? Очевидно, результати повинні були б бути однаковими ...

Приклад:

myCollection.OrderBy(item => item.CreatedDate).Where(item => item.Code > 3);
myCollection.Where(item => item.Code > 3).OrderBy(item => item.CreatedDate);

Обидва повертають мені однакові результати, але в іншому порядку LINQ. Я усвідомлюю, що переупорядкування деяких елементів призведе до різних результатів, і мене це не хвилює. Моє головне питання полягає в тому, щоб дізнатися, якщо отримання однакових результатів замовлення може вплинути на ефективність роботи. І не лише на 2 дзвінки LINQ, які я здійснив (OrderBy, Where), а на будь-які дзвінки LINQ.

Це залежатиме від постачальника LINQ, який використовується. Що стосується LINQ до об'єктів, це, безумовно, може змінити величезну зміну. Припустимо, що насправді у нас є:

var query = myCollection.OrderBy(item => item.CreatedDate)
                        .Where(item => item.Code > 3);

var result = query.Last();

Це вимагає , щоб вся колекція буде впорядкований і потім фільтрують. Якби у нас був мільйон предметів, лише в одному з яких був код більше 3, ми б витрачали багато часу, замовляючи результати, які були б викинуті.

Порівняйте це із зворотним режимом, фільтруючи спочатку:

var query = myCollection.Where(item => item.Code > 3)
                        .OrderBy(item => item.CreatedDate);

var result = query.Last();

На цей раз ми замовляємо лише відфільтровані результати, що у прикладі "лише один елемент, що відповідає фільтру" буде набагато ефективнішим - як у часі, так і в просторі.

Це також може змінити, чи правильно виконується запит чи ні. Поміркуйте:

var query = myCollection.Where(item => item.Code != 0)
                        .OrderBy(item => 10 / item.Code);

var result = query.Last();

Це добре - ми знаємо, що ми ніколи не ділимо на 0. Але якщо ми виконаємо замовлення перед фільтруванням, запит буде виключати виняток.

Так.

Але саме те , що різниця в продуктивності, залежить від того, як лежить в основі виразу дерева оцінюється постачальником LINQ.

Наприклад, ваш запит може виконуватись швидше вдруге (з першого пункту WHERE) для LINQ-to-XML, але швидше в перший раз для LINQ-до-SQL.

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

У вашому конкретному прикладі це може змінити продуктивність.

Перший запит: Ваш OrderByдзвінок потрібно повторити через всю послідовність джерел, включаючи ті елементи, де Code3 або менше. Тоді цей Whereпункт також повинен повторити всю упорядковану послідовність.

Другий запит: WhereВиклик обмежує послідовність лише на тих пунктах, де Codeбільше 3. OrderByВиклик тоді повинен лише пройти зменшену послідовність, повернуту Whereвикликом.

У Linq-To-Objects:

Сортування досить повільне і використовує O(n)пам'ять. Whereз іншого боку, відносно швидкий і використовує постійну пам'ять. Так що робити Whereспочатку буде швидше, а для великих колекцій значно швидше.

Знижений тиск пам’яті теж може бути суттєвим, оскільки виділення на великій купі об’єктів (разом з їх колекцією) є досить дорогими на мій досвід.

Очевидно, результати повинні були б бути однаковими ...

Зауважте, що це насправді не так - зокрема, наступні два рядки дадуть різні результати (для більшості постачальників / наборів даних):

myCollection.OrderBy(o => o).Distinct();
myCollection.Distinct().OrderBy(o => o);

Варто зазначити, що вам слід бути обережними, розглядаючи, як оптимізувати запит LINQ. Наприклад, якщо ви використовуєте декларативну версію LINQ, виконайте такі дії:

public class Record
{
    public string Name { get; set; }
    public double Score1 { get; set; }
    public double Score2 { get; set; }
}


var query = from record in Records
            order by ((record.Score1 + record.Score2) / 2) descending
            select new
                   {
                       Name = record.Name,
                       Average = ((record.Score1 + record.Score2) / 2)
                   };

Якщо з будь-якої причини ви вирішили "оптимізувати" запит, зберігаючи спочатку середню величину, ви не отримаєте бажаних результатів:

// The following two queries actually takes up more space and are slower
var query = from record in Records
            let average = ((record.Score1 + record.Score2) / 2)
            order by average descending
            select new
                   {
                       Name = record.Name,
                       Average = average
                   };

var query = from record in Records
            let average = ((record.Score1 + record.Score2) / 2)
            select new
                   {
                       Name = record.Name,
                       Average = average
                   }
            order by average descending;

Я знаю, що не багато людей використовують декларативний LINQ для об’єктів, але це хороша їжа для роздумів.

Це залежить від релевантності. Припустимо, якщо у вас дуже мало предметів з кодом = 3, наступне замовлення буде працювати над невеликим набором колекцій, щоб отримати замовлення за датою.

Якщо у вас є багато предметів з тим же CreateDate, наступне замовлення буде працювати над більшим набором колекції, щоб отримати замовлення за датою.

Отже, в обох випадках буде різниця у продуктивності