Приведи пример отношения many-to-many

Пример отношения Many-to-Many в C# и Entity Framework Core

Отношение many-to-many (многие-ко-многим) — это тип связи, при котором каждая запись одной таблицы может быть связана с несколькими записями другой таблицы, и наоборот. В реальных приложениях это одна из наиболее распространенных связей, требующая промежуточной таблицы (джойн-таблицы) для хранения пар идентификаторов.

Классический пример: Студенты и Курсы

Рассмотрим систему, где студенты могут записываться на множество курсов, а каждый курс может посещаться множеством студентов.

1. Определение основных сущностей

Создаем два основных класса, которые не содержат прямых ссылок друг на друга:

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    
    // Навигационное свойство к промежуточной сущности
    public ICollection<StudentCourse> StudentCourses { get; set; }
}

public class Course
{
    public int Id { get; set; }
    public string Title { get; set; }
    public int Credits { get; set; }
    
    // Навигационное свойство к промежуточной сущности
    public ICollection<StudentCourse> StudentCourses { get; set; }
}

2. Создание промежуточной сущности (джойн-таблицы)

В Entity Framework Core 5+ рекомендуется явно создавать класс для промежуточной таблицы:

public class StudentCourse
{
    public int StudentId { get; set; }
    public Student Student { get; set; }
    
    public int CourseId { get; set; }
    public Course Course { get; set; }
    
    // Дополнительные свойства связи (опционально)
    public DateTime EnrollmentDate { get; set; }
    public decimal? Grade { get; set; }
}

3. Конфигурация в DbContext

Настраиваем связи в классе контекста базы данных:

public class UniversityDbContext : DbContext
{
    public DbSet<Student> Students { get; set; }
    public DbSet<Course> Courses { get; set; }
    public DbSet<StudentCourse> StudentCourses { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Настройка составного ключа для промежуточной таблицы
        modelBuilder.Entity<StudentCourse>()
            .HasKey(sc => new { sc.StudentId, sc.CourseId });
        
        // Настройка связи Student -> StudentCourse
        modelBuilder.Entity<StudentCourse>()
            .HasOne(sc => sc.Student)
            .WithMany(s => s.StudentCourses)
            .HasForeignKey(sc => sc.StudentId)
            .OnDelete(DeleteBehavior.Cascade);
        
        // Настройка связи Course -> StudentCourse
        modelBuilder.Entity<StudentCourse>()
            .HasOne(sc => sc.Course)
            .WithMany(c => c.StudentCourses)
            .HasForeignKey(sc => sc.CourseId)
            .OnDelete(DeleteBehavior.Cascade);
    }
}

4. Работа с данными

Пример добавления связей и запросов к данным:

// Добавление связей many-to-many
public async Task EnrollStudentInCourse(int studentId, int courseId)
{
    var enrollment = new StudentCourse
    {
        StudentId = studentId,
        CourseId = courseId,
        EnrollmentDate = DateTime.UtcNow
    };
    
    await _context.StudentCourses.AddAsync(enrollment);
    await _context.SaveChangesAsync();
}

// Получение всех курсов для конкретного студента
public async Task<List<Course>> GetStudentCourses(int studentId)
{
    return await _context.Students
        .Where(s => s.Id == studentId)
        .SelectMany(s => s.StudentCourses)
        .Select(sc => sc.Course)
        .ToListAsync();
}

// Получение всех студентов на конкретном курсе
public async Task<List<Student>> GetCourseStudents(int courseId)
{
    return await _context.Courses
        .Where(c => c.Id == courseId)
        .SelectMany(c => c.StudentCourses)
        .Select(sc => sc.Student)
        .ToListAsync();
}

5. Альтернативный подход (EF Core 5.0+)

В Entity Framework Core 5.0+ можно использовать скрытую промежуточную таблицу без явного создания сущности:

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    
    // Прямая навигация к Course
    public ICollection<Course> Courses { get; set; }
}

public class Course
{
    public int Id { get; set; }
    public string Title { get; set; }
    
    // Прямая навигация к Student
    public ICollection<Student> Students { get; set; }
}

// Конфигурация в DbContext
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .HasMany(s => s.Courses)
        .WithMany(c => c.Students)
        .UsingEntity<Dictionary<string, object>>(
            "StudentCourse",
            j => j.HasOne<Course>().WithMany().HasForeignKey("CourseId"),
            j => j.HasOne<Student>().WithMany().HasForeignKey("StudentId"),
            j =>
            {
                j.Property<DateTime>("EnrollmentDate").HasDefaultValueSql("GETDATE()");
            });
}

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

• Гибкость — возможность добавлять дополнительные свойства в связь (дата зачисления, оценка, статус)
• Производительность — более эффективные запросы при сложной фильтрации
• Явность — четкая структура данных, соответствующая схеме базы данных
• Совместимость — работает во всех версиях EF Core

Типичные сценарии использования many-to-many:

• Социальные сети: Пользователи и группы
• Электронная коммерция: Заказы и товары
• Блоги: Статьи и теги
• Системы контроля доступа: Пользователи и роли

Отношение many-to-many является фундаментальным паттерном проектирования баз данных, и правильная его реализация в Entity Framework Core обеспечивает чистоту кода, производительность и удобство сопровождения приложения. Явное создание промежуточной сущности рекомендуется в большинстве случаев, особенно когда связи имеют собственные атрибуты или бизнес-логику.