Lavorare con l'approccio EF Core Code-First è un modo efficace per creare un'applicazione .NET Core Web API con un database relazionale. In questo articolo, esploreremo i passaggi necessari per configurare un progetto, definire il modello dei dati, generare il database utilizzando le migrazioni e creare un'API per gestire le operazioni CRUD. Seguiamo un approccio dettagliato e ricco di informazioni per aiutarti a comprendere appieno il processo.
Configurazione del progetto ASP.NET Core Web API
Prima di iniziare a lavorare con EF Core Code-First, è necessario configurare un progetto ASP.NET Core Web API. Segui questi passaggi:
- Crea un nuovo progetto ASP.NET Core Web API utilizzando il comando di creazione del progetto di .NET Core CLI o l'interfaccia utente di Visual Studio.
- Configura il progetto per utilizzare EF Core aggiungendo il pacchetto NuGet
Microsoft.EntityFrameworkCore.SqlServeral progetto. - Configura la connessione al database nel file
appsettings.jsonutilizzando la stringa di connessione corretta per il tuo database SQL Server.
Definizione del modello dei dati
Una volta configurato il progetto, puoi iniziare a definire il modello dei dati utilizzando le classi delle entità. Nel nostro esempio, creeremo una classe Employee con diverse proprietà come EmployeeId, FirstName, LastName, DateOfBirth, PhoneNumber e Email. Utilizzeremo anche gli attributi [Key] e [DatabaseGenerated] per specificare la chiave primaria e la generazione automatica del valore dell'ID dell'impiegato.
using System;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace EFCoreCodeFirstSample.Models
{
public class Employee
{
[Key]
[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
public long EmployeeId { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public DateTime DateOfBirth { get; set; }
public string PhoneNumber { get; set; }
public string Email { get; set; }
}
}Creazione del contesto del database
Dopo aver definito il modello dei dati, è necessario creare un contesto del database che gestisca la connessione e le operazioni di accesso ai dati. Creeremo una classe EmployeeContext che eredita dalla classe DbContext di EF Core. Nel costruttore di questa classe, passeremo le opzioni del contesto del database.
using Microsoft.EntityFrameworkCore;
namespace EFCoreCodeFirstSample.Models
{
public class EmployeeContext : DbContext
{
public EmployeeContext(DbContextOptions<EmployeeContext> options) : base(options)
{
}
public DbSet<Employee> Employees { get; set; }
}
}Generazione del database utilizzando le migrazioni
Una volta definito il contesto del database, possiamo generare il database effettivo utilizzando le migrazioni. Le migrazioni sono un modo per creare e aggiornare automaticamente il database in base al modello dei dati definito. Segui questi passaggi:
- Apri la console di gestione dei pacchetti nel tuo IDE (ad esempio, Visual Studio) e seleziona il progetto principale.
- Esegui il comando
Add-Migrationseguito da un nome significativo per la migrazione. Ad esempio,Add-Migration InitialCreatecreerà una migrazione iniziale con il nome "InitialCreate". - Esegui il comando
Update-Databaseper applicare le migrazioni al database. Questo creerà le tabelle e le colonne corrispondenti al modello dei dati definito.
Utilizzo del repository per l'accesso ai dati
Per accedere ai dati dal nostro API Controller, utilizzeremo un repository che implementa un'interfaccia IDataRepository. Questo repository gestirà le operazioni CRUD sui dati degli impiegati. Creeremo una classe EmployeeManager che implementa l'interfaccia IDataRepository<Employee>. Questa classe utilizzerà il contesto del database per eseguire le operazioni sui dati.
using System.Collections.Generic;
using System.Linq;
using EFCoreCodeFirstSample.Models.Repository;
namespace EFCoreCodeFirstSample.Models.DataManager
{
public class EmployeeManager : IDataRepository<Employee>
{
private readonly EmployeeContext _employeeContext;
public EmployeeManager(EmployeeContext context)
{
_employeeContext = context;
}
public IEnumerable<Employee> GetAll()
{
return _employeeContext.Employees.ToList();
}
public Employee Get(long id)
{
return _employeeContext.Employees.FirstOrDefault(e => e.EmployeeId == id);
}
public void Add(Employee entity)
{
_employeeContext.Employees.Add(entity);
_employeeContext.SaveChanges();
}
public void Update(Employee employee, Employee entity)
{
employee.FirstName = entity.FirstName;
employee.LastName = entity.LastName;
employee.Email = entity.Email;
employee.DateOfBirth = entity.DateOfBirth;
employee.PhoneNumber = entity.PhoneNumber;
_employeeContext.SaveChanges();
}
public void Delete(Employee employee)
{
_employeeContext.Employees.Remove(employee);
_employeeContext.SaveChanges();
}
}
}Creazione dell'API Controller
Infine, creeremo un API Controller che gestirà le richieste HTTP per le operazioni CRUD sui dati degli impiegati. Questo controller utilizzerà il repository EmployeeManager per accedere ai dati. Creeremo i metodi per le operazioni GET, POST, PUT e DELETE.
using System.Collections.Generic;
using EFCoreCodeFirstSample.Models;
using EFCoreCodeFirstSample.Models.Repository;
using Microsoft.AspNetCore.Mvc;
namespace EFCoreCodeFirstSample.Controllers
{
[Route("api/employee")]
[ApiController]
public class EmployeeController : ControllerBase
{
private readonly IDataRepository<Employee> _dataRepository;
public EmployeeController(IDataRepository<Employee> dataRepository)
{
_dataRepository = dataRepository;
}
[HttpGet]
public IActionResult Get()
{
IEnumerable<Employee> employees = _dataRepository.GetAll();
return Ok(employees);
}
[HttpGet("{id}", Name = "Get")]
public IActionResult Get(long id)
{
Employee employee = _dataRepository.Get(id);
if (employee == null)
{
return NotFound("The Employee record couldn't be found.");
}
return Ok(employee);
}
[HttpPost]
public IActionResult Post([FromBody] Employee employee)
{
if (employee == null)
{
return BadRequest("Employee is null.");
}
_dataRepository.Add(employee);
return CreatedAtRoute("Get", new { Id = employee.EmployeeId }, employee);
}
[HttpPut("{id}")]
public IActionResult Put(long id, [FromBody] Employee employee)
{
if (employee == null)
{
return BadRequest("Employee is null.");
}
Employee employeeToUpdate = _dataRepository.Get(id);
if (employeeToUpdate == null)
{
return NotFound("The Employee record couldn't be found.");
}
_dataRepository.Update(employeeToUpdate, employee);
return NoContent();
}
[HttpDelete("{id}")]
public IActionResult Delete(long id)
{
Employee employee = _dataRepository.Get(id);
if (employee == null)
{
return NotFound("The Employee record couldn't be found.");
}
_dataRepository.Delete(employee);
return NoContent();
}
}
}Conclusioni
In questo articolo, abbiamo esplorato come lavorare con l'approccio EF Core Code-First per creare un'applicazione .NET Core Web API con un database relazionale. Abbiamo coperto i passaggi necessari per configurare il progetto, definire il modello dei dati, generare il database utilizzando le migrazioni e creare un'API per gestire le operazioni CRUD. Seguendo questi passaggi, sarai in grado di creare un'applicazione robusta e scalabile utilizzando EF Core Code-First. Buon lavoro!