Продвинутый LINQ и обобщения

В этом уроке ты узнаешь

Строить отчёты по группам с GroupBy, CountBy и ToLookup
Объединять коллекции через Join, GroupJoin, LeftJoin и SelectMany
Объяснять отложенное выполнение, писать обобщённые методы с ограничениями и методы расширения

Основы LINQ ты уже знаешь: Where, Select, OrderBy. Но настоящие данные редко лежат в одном списке: ученики хранятся в одной таблице, предметы — во второй, оценки — в третьей. В этом уроке ты научишься соединять, группировать и «сплющивать» их с помощью LINQ, а затем изучишь инструменты, из которых построен сам LINQ, — обобщения (generics), их ограничения и методы расширения.

Группировка: GroupBy, CountBy, ToLookup

GroupBy делит элементы на группы по ключу, и каждая группа — это коллекция со свойством Key. В сочетании с Select каждая группа превращается в строку отчёта: количество, среднее, лучший результат. Появившийся в .NET 9 CountBy отвечает на вопрос «сколько элементов с каждым ключом?» за один шаг, а ToLookup сразу вычисляет результат и хранит его для поиска по ключу (для отсутствующего ключа возвращает пустую последовательность).

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

List<Student> students =
[
    new("Aysel", "10A", 95), new("Murad", "10B", 78), new("Leyla", "10A", 88),
    new("Elvin", "10B", 45), new("Nigar", "11A", 91), new("Kamran", "10A", 67)
];

var byClass = students
    .GroupBy(s => s.Class)
    .Select(g => new
    {
        Class = g.Key,
        Count = g.Count(),
        Average = g.Average(s => s.Score),
        Best = g.MaxBy(s => s.Score)!.Name
    })
    .OrderByDescending(x => x.Average);

foreach (var c in byClass)
    Console.WriteLine($"{c.Class} ({c.Count}): average {c.Average:F1}, best {c.Best}");

foreach (var (cls, count) in students.CountBy(s => s.Class))
    Console.Write($"{cls}={count} ");
Console.WriteLine();

ILookup<string, string> namesByClass = students.ToLookup(s => s.Class, s => s.Name);
Console.WriteLine(string.Join(", ", namesByClass["10B"]));

record Student(string Name, string Class, int Score);

Ожидаемый результат

11A (1): average 91.0, best Nigar
10A (3): average 83.3, best Aysel
10B (2): average 61.5, best Murad
10A=3 10B=2 11A=1 
Murad, Elvin

Анонимный тип (new { ... }) хранит строку отчёта; MaxBy находит лучшего ученика, не сортируя группу

Join, GroupJoin и SelectMany

Join соединяет две коллекции по общему ключу — как INNER JOIN в SQL: в результат попадают только элементы, для которых нашлась пара. GroupJoin даёт каждому левому элементу группу подходящих правых элементов, и группа может быть пустой — поэтому Лейла, у которой нет ни одного курса, тоже видна. SelectMany превращает вложенные коллекции в одну плоскую последовательность: из расписаний по дням получается единый список всех предметов.

List<Student> students = [new(1, "Aysel"), new(2, "Murad"), new(3, "Leyla")];
List<Course> courses = [new(10, "Math"), new(20, "Physics")];
List<Enrollment> enrollments = [new(1, 10, 95), new(1, 20, 88), new(2, 10, 78)];

// inner join: only students who have enrollments
var rows = enrollments
    .Join(students, e => e.StudentId, s => s.Id, (e, s) => new { s.Name, e.CourseId, e.Score })
    .Join(courses, x => x.CourseId, c => c.Id, (x, c) => $"{x.Name} - {c.Title}: {x.Score}");
foreach (var row in rows) Console.WriteLine(row);

// GroupJoin: every student with the group of their enrollments
var counts = students.GroupJoin(enrollments, s => s.Id, e => e.StudentId,
    (s, list) => $"{s.Name}: {list.Count()}");
Console.WriteLine(string.Join(", ", counts));

// SelectMany flattens nested collections
string[][] timetable = [["Math", "Physics"], ["Math", "Art"], ["Chemistry"]];
var subjects = timetable.SelectMany(day => day).Distinct().Order();
Console.WriteLine(string.Join(", ", subjects));

record Student(int Id, string Name);
record Course(int Id, string Title);
record Enrollment(int StudentId, int CourseId, int Score);

Ожидаемый результат

Aysel - Math: 95
Aysel - Physics: 88
Murad - Math: 78
Aysel: 2, Murad: 1, Leyla: 0
Art, Chemistry, Math, Physics

Три «таблицы» — как students, courses и enrollments в курсе SQL

Когда соединений много, похожий на SQL синтаксис запросов часто читается легче: from e in enrollments join s in students on e.StudentId equals s.Id select .... Для сравнения здесь пишут ключевое слово equals, а не ==, а join ... into g превращается в GroupJoin. let позволяет дать имя промежуточному результату: let passed = e.Score >= 50. Компилятор превращает обе записи в одни и те же вызовы методов, поэтому разницы в скорости нет.

Старое левое соединение: `GroupJoin` + `SelectMany` + `DefaultIfEmpty`

var result = students
    .GroupJoin(enrollments, s => s.Id, e => e.StudentId, (s, list) => new { s, list })
    .SelectMany(x => x.list.DefaultIfEmpty(),
                (x, e) => $"{x.s.Name}: {e?.Score.ToString() ?? "no score"}");

.NET 10: `LeftJoin`

var result = students
    .LeftJoin(enrollments, s => s.Id, e => e.StudentId,
              (s, e) => $"{s.Name}: {e?.Score.ToString() ?? "no score"}");
// students without enrollments are kept: Leyla: no score

.NET 10 добавил в LINQ методы LeftJoin и RightJoin; оба варианта дают одинаковый результат (проверено)

Отложенное выполнение: когда работает запрос?

В уроке об основах ты видел, что Where и Select ничего не вычисляют сразу. Итератор с yield return ниже показывает это «изнутри», печатая каждый элемент: First() останавливается, как только находит первое совпадение, а Count() выполняет всю цепочку заново, от начала до конца. Если источник — база данных или сеть, каждый новый перебор означает новый запрос.

var query = Numbers().Where(n => n % 2 == 1).Select(n => n * 10);
Console.WriteLine("Query created");
Console.WriteLine($"First: {query.First()}");
Console.WriteLine($"Count: {query.Count()}");

IEnumerable<int> Numbers()
{
    for (int i = 1; i <= 5; i++)
    {
        Console.WriteLine($"  producing {i}");
        yield return i;
    }
}

Ожидаемый результат

Query created
  producing 1
First: 10
  producing 1
  producing 2
  producing 3
  producing 4
  producing 5
Count: 3

При создании запроса ничего не напечаталось; First() запросил один элемент, а Count() снова прошёл по всем

Обобщения и ограничения

Обобщённый метод или класс пишется один раз и работает с разными типами: Max<T> сравнивает и числа, и строки. Но если о T ничего не известно, с ним почти ничего нельзя сделать. Ограничение (where) сообщает компилятору, что умеет T: where T : IComparable<T> — есть CompareTo; where T : INumber<T> — есть + и T.Zero (это обобщённая математика, доступная с .NET 7); where T : class, IEntity — T является ссылочным типом со свойством Id.

using System.Globalization;
using System.Numerics;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

Console.WriteLine(Max([3, 9, 4]));
Console.WriteLine(Max(["pear", "apple", "plum"]));
Console.WriteLine(Sum([1, 2, 3]));
Console.WriteLine(Sum([1.5, 2.25]));

var repo = new Repository<Student>();
repo.Add(new Student(1, "Aysel"));
Console.WriteLine(repo.Find(1)?.Name ?? "none");
Console.WriteLine(repo.Find(7)?.Name ?? "none");

static T Max<T>(IEnumerable<T> items) where T : IComparable<T>
{
    T best = items.First();
    foreach (T item in items)
        if (item.CompareTo(best) > 0) best = item;
    return best;
}

static T Sum<T>(IEnumerable<T> items) where T : INumber<T>
{
    T total = T.Zero;
    foreach (T item in items) total += item;
    return total;
}

interface IEntity { int Id { get; } }
record Student(int Id, string Name) : IEntity;

class Repository<T> where T : class, IEntity
{
    private readonly Dictionary<int, T> items = [];
    public void Add(T item) => items[item.Id] = item;
    public T? Find(int id) => items.GetValueOrDefault(id);
}

Ожидаемый результат

9
plum
6
3.75
Aysel
none

Один Sum<T> работает и для int, и для double; Repository<T> может хранить любой класс с Id

Ограничение	Смысл
`where T : class`	ссылочный тип (класс, запись, интерфейс)
`where T : struct`	значимый тип (`int`, `DateTime`, структура)
`where T : new()`	есть конструктор без параметров: можно писать `new T()`
`where T : notnull`	тип, который не может быть `null`
`where T : IComparable<T>`	реализует указанный интерфейс
`where T : INumber<T>`	число: работают `+`, `-`, `T.Zero`, `T.One`

Методы расширения

Все методы LINQ — Where, Select, GroupBy — это методы расширения: они написаны в статическом классе System.Linq.Enumerable, но вызываются как собственные методы IEnumerable<T>. Свой метод можно написать так же: static-метод в static-классе, а перед первым параметром — this. В C# 14 появились блоки расширения: внутри extension(Student student) { ... } можно объявлять не только методы, но и свойства.

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

int[] scores = [95, 78, 88, 45];
Console.WriteLine(scores.Median());
Console.WriteLine("aysel mammadova".ToTitle());

var leyla = new Student("Leyla", 88);
Console.WriteLine($"{leyla.Name} passed: {leyla.IsPassing}");

static class StatsExtensions
{
    public static double Median(this IEnumerable<int> source)
    {
        int[] sorted = source.Order().ToArray();
        int mid = sorted.Length / 2;
        return sorted.Length % 2 == 0 ? (sorted[mid - 1] + sorted[mid]) / 2.0 : sorted[mid];
    }

    public static string ToTitle(this string text) =>
        CultureInfo.InvariantCulture.TextInfo.ToTitleCase(text);
}

static class StudentExtensions
{
    extension(Student student)             // C# 14: an extension block
    {
        public bool IsPassing => student.Score >= 50;
    }
}

record Student(string Name, int Score);

Ожидаемый результат

83
Aysel Mammadova
Leyla passed: True

Median «добавлен» массивам, ToTitle — строкам, IsPassing — Student, а исходные типы не изменились

Классический метод расширения

static class StudentExtensions
{
    // classic extension method: must be called with ()
    public static bool IsPassing(this Student student) => student.Score >= 50;
}
// usage: leyla.IsPassing()

C# 14: свойство расширения

static class StudentExtensions
{
    extension(Student student)      // C# 14: extension properties are possible too
    {
        public bool IsPassing => student.Score >= 50;
    }
}
// usage: leyla.IsPassing

Главное

GroupBy + Select строят отчёт по группам; CountBy считает, а ToLookup хранит группы для поиска.
Join — внутреннее соединение, GroupJoin — группы с сохранением левой стороны, SelectMany — «сплющивание»; в .NET 10 есть LeftJoin.
Запросы LINQ ленивы: каждый перебор выполняет их заново; ToList() «замораживает» результат.
Ограничения (where T : ...) сообщают, что умеет T; INumber<T> открывает обобщённую математику.
Метод расширения — static-метод с параметром this в static-классе; в C# 14 можно добавлять и свойства.

Проверь себя

Вопросов: 10. Каждый правильный ответ приносит XP.

1 / 10

Что возвращает students.CountBy(s => s.Class) для данных из урока?