https://github.com/eliasprates/relationshipsefcore
Relationships in EF Core - Relacionamentos no EF Core - 1:1 - 1:N - N:N - Fluent API
https://github.com/eliasprates/relationshipsefcore
dependency-injection dotnet entity-framework-core fluent-api relationships
Last synced: 7 months ago
JSON representation
Relationships in EF Core - Relacionamentos no EF Core - 1:1 - 1:N - N:N - Fluent API
- Host: GitHub
- URL: https://github.com/eliasprates/relationshipsefcore
- Owner: eliasprates
- License: mit
- Created: 2024-01-24T13:54:28.000Z (over 1 year ago)
- Default Branch: master
- Last Pushed: 2024-01-28T11:41:36.000Z (over 1 year ago)
- Last Synced: 2025-01-15T04:39:26.484Z (9 months ago)
- Topics: dependency-injection, dotnet, entity-framework-core, fluent-api, relationships
- Language: C#
- Homepage: https://learn.microsoft.com/en-us/ef/core/modeling/relationships
- Size: 13.7 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Mapeamento de Relacionamentos no Entity Framework Core
Este documento fornece uma visão geral de como mapear relacionamentos entre entidades usando o Entity Framework Core. Utilizando as entidades `Enrollment`, `School`, `Student`, e `Teacher` como exemplos, demonstramos diferentes tipos de relacionamentos: um-para-um, um-para-muitos e muitos-para-muitos.
## Entidades
Aqui estão as entidades básicas utilizadas:
### `Enrollment`
```csharp
public class Enrollment
{
public int Id { get; set; }
public int EnrollmentNumber { get; set; }
public DateTime EnrollmentDate { get; set; }
}
```
### `School`
```csharp
public class School
{
public int Id { get; set; }
public string? Name { get; set; }
public string? Address { get; set; }
public string? Phone { get; set; }
public string? Principal { get; set; }
public List? Teachers { get; set; }
public List? Students { get; set; }
}
```
### `Student`
```csharp
public class Student
{
public int Id { get; set; }
public string? Name { get; set; }
public int Age { get; set; }
public int EnrollmentId { get; set; }
public int SchoolId { get; set; }
public Enrollment? Enrollment { get; set; }
public School? School { get; set; }
public List? Teachers { get; set; }
}
```
### `Teacher`
```csharp
public class Teacher
{
public int Id { get; set; }
public string? Name { get; set; }
public string? Subject { get; set; }
public List? Schools { get; set; }
public List? Students { get; set; }
}
```
## Configuração de DbContext
A classe `ApplicationDbContext` é configurada com `DbSet` para cada uma das entidades e o mapeamento de relacionamentos é feito usando Fluent API no método `OnModelCreating`.
### Exemplo de `ApplicationDbContext`
```csharp
public class ApplicationDbContext : DbContext
{
public DbSet Enrollments { get; set; }
public DbSet Schools { get; set; }
public DbSet Students { get; set; }
public DbSet Teachers { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// Configurações dos modelos e seus relacionamentos
// ...
}
}
```
## Mapeamento de Relacionamentos
### Relacionamentos Um-para-Um
- **Student - Enrollment:** Cada estudante (`Student`) possui um registro de matrícula (`Enrollment`).
### Relacionamentos Um-para-Muitos
- **School - Student:** Uma escola (`School`) pode ter vários estudantes (`Student`).
### Relacionamentos Muitos-para-Muitos
- **School - Teacher:** Uma escola (`School`) pode ter vários professores (`Teacher`), e um professor (`Teacher`) pode ensinar em várias escolas (`School`).
- **Student - Teacher:** Um estudante (`Student`) pode ser ensinado por vários professores (`Teacher`), e um professor (`Teacher`) pode ensinar vários estudantes (`Student`).
## Considerações Finais
Este README fornece um guia básico para o mapeamento de relacionamentos usando o Entity Framework Core. Para cada tipo de relacionamento, é crucial entender como configurar corretamente as entidades e suas relações para garantir um modelo de dados eficiente e eficaz.
## `ApplicationDbContext` e Mapeamento no `OnModelCreating`
A classe `ApplicationDbContext` é o ponto central para configurar as regras de mapeamento das entidades para o banco de dados. No método `OnModelCreating`, utilizamos a Fluent API para definir detalhadamente como as entidades são mapeadas, incluindo o tipo de relacionamentos entre elas.
### Exemplo Detalhado de `OnModelCreating`
```csharp
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// Relacionamento Um-Para-Um: Student - Enrollment
modelBuilder.Entity()
.HasOne(s => s.Enrollment)
.WithOne()
.HasForeignKey(s => s.EnrollmentId);
// Relacionamento Um-Para-Muitos: School - Student
modelBuilder.Entity()
.HasMany(s => s.Students)
.WithOne(s => s.School)
.HasForeignKey(s => s.SchoolId);
// Relacionamento Muitos-Para-Muitos: School - Teacher
modelBuilder.Entity()
.HasMany(s => s.Teachers)
.WithMany(t => t.Schools);
// Relacionamento Muitos-Para-Muitos: Student - Teacher
modelBuilder.Entity()
.HasMany(s => s.Teachers)
.WithMany(t => t.Students);
// Outras configurações...
}
```
Cada método na Fluent API é usado para especificar um aspecto diferente do mapeamento:
- `HasKey`: Define a chave primária da entidade.
- `HasMany`/`WithOne`/`WithMany`: Define os tipos de relacionamentos entre as entidades.
- `HasForeignKey`: Especifica a chave estrangeira em um relacionamento.
- `Property`: Usado para configurar aspectos das propriedades, como tamanho máximo.
Este mapeamento assegura que o EF Core possa traduzir corretamente suas operações em comandos de banco de dados que respeitam as relações entre as entidades.
## Considerações Finais
Este guia oferece um panorama de como configurar e mapear relacionamentos no Entity Framework Core. Estas configurações são fundamentais para um aproveitamento eficaz do EF Core e para garantir a integridade dos dados em seu banco de dados.