C# C# · 25 вопросов · ~70 мин · ⏱ Таймер 10:00 · Сложный ·

LINQ к объектам

Проверяет LINQ к объектам через фильтрацию, проекцию, группировку, соединение и отложенное выполнение. Особое внимание уделено повторному перечислению, изменению источника и тому, когда удобная цепочка незаметно выполняет работу несколько раз.

Отвечено: 0 из 25

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. На 25 вопросов отведено 70 минут. В заданиях с кодом учитывайте указанную конструкцию и не додумывайте отсутствующие условия. После завершения откроются общий результат, тематические шкалы и разбор каждого ответа.

Вопрос 1 из 25

Какие значения останутся после фильтрации чётных чисел и умножения их на два?

var result = new[] { 1, 2, 3, 4 }
    .Where(x => x % 2 == 0)
    .Select(x => x * 2);
Console.WriteLine(string.Join(',', result));

1,2,3,4 8 Пусто 4,8 2,4

Вопрос 2 из 25

Что возвращает Select в этой цепочке?

IEnumerable<string> names = customers.Select(c => c.Name);

Dictionary Один первый Customer bool Те же Customer с изменённым Name Последовательность строк с именами

Вопрос 3 из 25

Как выбрать номера исходных позиций элементов, равных "x"?

Применить Aggregate без отдельного состояния позиции SelectMany передаёт исходный индекс автоматически даже без индексированной перегрузки Отсортировать по GetHashCode и взять номера после сортировки Использовать Cast<int>, потому что индекс хранится в каждом элементе Использовать индексированную перегрузку Select или Where и сохранить индекс вместе со значением

Вопрос 4 из 25

Изменит ли цепочка исходный список?

var source = new List<int> { 1, 2, 3 };
var query = source.Where(x => x > 1).Select(x => x * 10);

Нет: Where и Select не изменяют источник Да, Select заменит значения В Release оптимизатор изменит исходный список, чтобы не создавать промежуточную последовательность Да, удалит нечётные элементы Только если список readonly

Вопрос 5 из 25

Почему Where(x => Expensive(x)).Select(...) иногда стоит ставить после дешёвого фильтра?

После Where нельзя вызывать Select, если предикат содержит дорогую операцию Перестановка фильтров меняет тип элементов с int на bool и сокращает перечисление LINQ меняет порядок источника, чтобы дорогой предикат запускался реже Ранний дешёвый фильтр уменьшает число дорогих проверок для последующих операторов Ранний фильтр включает параллельный режим сборщика мусора для оставшихся элементов

Вопрос 6 из 25

Сколько групп получится?

var groups = new[] { 1, 2, 3, 4, 5 }.GroupBy(x => x % 2);
Console.WriteLine(groups.Count());

4 3 1 5 2

Вопрос 7 из 25

Что содержит g.Key?

Хеш всей группы Количество элементов Первый элемент группы Индекс группы Значение ключа, вычисленное селектором GroupBy

Вопрос 8 из 25

Как получить по одному объекту с Category и Count?

var summary = orders
    .GroupBy(o => o.Category)
    .Select(g => new { Category = g.Key, Count = g.Count() });

OrderBy без Select Cast<Dictionary>() Select с Category = g.Key и Count = g.Count() Where(g => g.Count()) Append(g.Key)

Вопрос 9 из 25

Как сгруппировать email без учёта регистра?

GroupBy(x => x.Email.Length) Перед GroupBy нужно отсортировать строки: comparer учитывается только у отсортированного источника Использовать ReferenceEquals Передать StringComparer.OrdinalIgnoreCase как comparer ключа Сравнивать только hash code

Вопрос 10 из 25

Почему GroupBy может быть тяжёлым для большого потока?

var grouped = hugeSequence.GroupBy(x => x.CustomerId);
// Первая выдача групп требует построить таблицу группировки.

Он выполняет только первый элемент Он создаёт поток на группу GroupBy передаётся провайдеру SQL даже для IEnumerable GroupBy хранит элементы по группам до выдачи Он запрещает value types

Вопрос 11 из 25

Какие строки будут в результате?

var left = new[] { (Id: 1, Name: "A"), (Id: 2, Name: "B") };
var right = new[] { (Id: 1, Code: "X"), (Id: 2, Code: "Y") };
var q = left.Join(right, l => l.Id, r => r.Id, (l, r) => $"{l.Name}:{r.Code}");

A:X B:Y Пусто A:X и B:Y A:null и B:Y

Вопрос 12 из 25

Что вернёт обычный Join для левого элемента без совпадения?

Пару с null Ни одного результата для этого элемента Пустую строку Исключение KeyNotFoundException Сам левый элемент

Вопрос 13 из 25

Как соединить по двум полям?

var q = left.Join(right,
    l => new { l.Region, l.Number },
    r => new { r.Region, r.Number },
    (l, r) => (l, r));

Одинаковый составной ключ из двух полей Сравнить GetHashCode Сложить поля в строку без разделителя Вызвать два Join подряд без условий Использовать только первый ключ

Вопрос 14 из 25

Когда GroupJoin предпочтительнее Join?

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

Вопрос 15 из 25

Почему repeated FirstOrDefault внутри Select может быть хуже Join/Lookup?

var q = customers.Select(c => new
{
    Customer = c,
    Order = orders.FirstOrDefault(o => o.CustomerId == c.Id)
});

FirstOrDefault меняет исходную коллекцию Select выполняется параллельно Join ищет совпадение без дополнительной структуры за O(1) FirstOrDefault повторно сканирует правую коллекцию FirstOrDefault запрещён для объектов

Вопрос 16 из 25

Сколько элементов увидит отложенный запрос после добавления 4 в исходный список?

var list = new List<int> { 1, 2, 3 };
var q = list.Where(x => x > 1);
list.Add(4);
Console.WriteLine(q.Count());

Ошибка 2 3 4 5

Вопрос 17 из 25

Как получить снимок результата до изменения источника?

Переименовать q Добавить ещё один Where Вызвать ToArray или ToList в нужный момент Вызвать GetHashCode Использовать var вместо IEnumerable

Вопрос 18 из 25

Почему два foreach по запросу могут дважды вызвать дорогой селектор?

var q = files.Select(ReadAndParse);
foreach (var x in q) Use(x);
foreach (var x in q) Audit(x);

Ленивый запрос обычно исполняется заново при каждом перечислении foreach очищает кэш LINQ Из-за boxing int Select вызывается только на этапе компиляции IEnumerable кэширует результат первого перечисления

Вопрос 19 из 25

Какой оператор здесь запускает перечисление?

var items = source
    .Where(IsValid)
    .Select(Convert)
    .ToList();

Объявление var ToList Where Select Лямбда

Вопрос 20 из 25

Чем опасно повторное перечисление потока, читающего файл?

Компилятор создаёт копию файла Итератор может быть однократным, дорогим или увидеть уже изменившийся внешний ресурс Второй проход по исчерпанному источнику возвращает пустую последовательность по контракту IEnumerable запрещает I/O Повторное перечисление переоткрывает файл и возвращает прежний снимок

Вопрос 21 из 25

Какой assert лучше для точной последовательности?

var actual = input.Where(x => x % 2 == 0).ToArray();
Assert.Equal(new[] { 2, 4 }, actual);

Assert.Equal(new[] {2,4}, actual) Assert.Equal(2, actual.Count()) только Assert.IsAssignableFrom<IEnumerable<int>>(actual) Assert.NotNull(actual) Assert.True(actual.Any())

Вопрос 22 из 25

Как проверить, что источник перечисляется только один раз?

Добавить Distinct: он гарантирует ровно один вызов GetEnumerator у исходной цепочки Поставить breakpoint в запросе, не считая повторные вызовы MoveNext автоматически Проверить лишь тип источника и предположить однократное перечисление Сравнить runtime-тип источника с List<T> и по типу сделать вывод о числе перечислений Тестовый enumerable со счётчиком GetEnumerator и MoveNext

Вопрос 23 из 25

Почему тест OrderBy должен включать равные ключи?

var actual = people.OrderBy(p => p.Age).ThenBy(p => p.Name).ToArray();
// В данных есть несколько людей одного возраста.

Равные ключи запрещены Только для строк Чтобы увеличить Count Чтобы включить GroupBy Равные ключи проверяют стабильность и ThenBy

Вопрос 24 из 25

Что полезно измерить в длинной LINQ-цепочке?

Только загрузку процессора без связи с конкретным запросом Количество вызванных методов независимо от объёма данных Размер источника без числа элементов после фильтров и группировок Только общее время всей цепочки без разделения на этапы Время, число элементов до и после дорогих этапов и аллокации на критичном пути

Вопрос 25 из 25

Почему селектор с записью в базу — плохая идея?

var q = orders.Select(o =>
{
    repository.Save(o); // скрытый побочный эффект при перечислении
    return o.Id;
});

База принимает только arrays Он не может вернуть значение LINQ откладывает побочные эффекты до транзакционного commit Побочные эффекты зависят от числа перечислений Select запрещает методы

Ответьте на все 25 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу