MyCodeSchool

Pasul 1 din 5

ASP.NET Core

Pasul 1 din 5 · Ce construiești

  • ASP.NET Core
  • Mediu
  • 13 minute

ASP.NET Core cu EF Core și MySQL: modelul și prima migrare

Construiești, în trei lecții, un API pentru ateliere și înscrieri. În prima parte legi aplicația de o bază de date MySQL: scrii două clase C#, iar Entity Framework Core face din ele tabele și salvează primul atelier. La final, datele rămân și după repornire.

al doilea terminal
curl -i -X POST http://localhost:5207/evenimente
HTTP/1.1 201 Created
Location: /evenimente/1

{"id":1,"titlu":"Atelier de robotică","data":"2026-12-05T00:00:00","locuri":12,"inscrieri":[]}

Ai nevoie de SDK-ul .NET 8 și de Docker, pentru MySQL. Pregătirea, o singură dată:

terminal
docker run -d --name evenimente-mysql \  -e MYSQL_ROOT_PASSWORD=parola-locala \  -e MYSQL_DATABASE=evenimente \  -p 3306:3306 mysql:8.4dotnet new web -n Evenimentecd Evenimentedotnet add package Pomelo.EntityFrameworkCore.MySql --version 8.0.3dotnet add package Microsoft.EntityFrameworkCore.Design --version 8.0.13dotnet tool install --global dotnet-ef --version "8.*"

Pomelo e furnizorul care învață EF Core să vorbească cu MySQL. Pachetul Design și unealta dotnet-ef sunt pentru migrații. Portul aplicației, aici 5207, îl vezi la dotnet run.

Pasul 2 din 5

Ce se întâmplă la salvare

Ruta de mai jos creează un atelier și îl salvează. Tabelele există deja, din pasul 3. Urmărește starea obiectului: EF Core ține evidența fiecărei entități și scrie în bază abia când îi ceri.

Program.cs, ruta POST
app.MapPost("/evenimente",    async (AppDbContext db) =>{    var e = new Eveniment    {        Titlu = "Atelier de robotică",        Data = new DateTime(2026, 12, 5),        Locuri = 12    };    db.Evenimente.Add(e);    await db.SaveChangesAsync();    return Results.Created(        $"/evenimente/{e.Id}", e);});

Stare

Log și răspuns


      

  1. Linia 2. Sosește POST /evenimente. ASP.NET Core creează un AppDbContext nou, doar pentru această cerere, și îl dă funcției ca parametru db.
  2. Linia 4. Un obiect C# obișnuit. EF Core nu știe de el: starea e Detached, iar Id e 0.
  3. Linia 10. Add îl înscrie în evidența contextului cu starea Added: „de inserat la salvare”. Nicio comandă n-a plecat încă spre MySQL, iar Id e tot 0.
  4. Linia 11. SaveChangesAsync transformă tot ce e marcat în SQL. Logul arată exact comanda trimisă. MySQL dă cheia, 1, iar EF Core o scrie în e.Id. Starea devine Unchanged: obiectul e identic cu rândul din bază.
  5. Linia 12. Răspunsul 201 conține noul Id și adresa atelierului.
  6. Gata. La finalul cererii, contextul e eliberat. Atelierul rămâne în MySQL, chiar dacă oprești aplicația.

Prezice rezultatul

Ștergi linia 11, cea cu SaveChangesAsync. Ce primește clientul și ce ajunge în MySQL?

Răspuns: 201 cu „id”:0, iar în bază nu ajunge nimic.

Add doar marchează obiectul. Fără SaveChangesAsync, nicio comandă nu pleacă spre MySQL, iar la finalul cererii contextul e aruncat, cu tot cu marcaj. Codul nu dă nicio eroare, de aceea greșeala e greu de observat.

Pasul 3 din 5

Clase, context, migrații

Trei piese, în ordinea în care le scrii. La final, cele două erori pe care le vei vedea sigur la primul proiect.

Entitățile: clase care devin tabele

Modele.cs
public class Eveniment{    public int Id { get; set; }    public string Titlu { get; set; } = "";    public DateTime Data { get; set; }    public int Locuri { get; set; }    public List<Inscriere> Inscrieri { get; set; }        = new();}public class Inscriere{    public int Id { get; set; }    public int EvenimentId { get; set; }    public Eveniment? Eveniment { get; set; }    public string Nume { get; set; } = "";}

EF Core citește clasele după convenții. O proprietate Id devine cheie primară cu auto-increment. EvenimentId, împreună cu proprietatea Eveniment, devine cheie străină spre tabela de evenimente.

Lista Inscrieri spune că un atelier are mai multe înscrieri: o relație unu la mulți. Ea nu devine coloană, ci o folosești ca să navighezi între obiecte.

DbContext: poarta spre bază

AppDbContext.cs
using Microsoft.EntityFrameworkCore;public class AppDbContext(    DbContextOptions<AppDbContext> options)    : DbContext(options){    public DbSet<Eveniment> Evenimente        => Set<Eveniment>();    public DbSet<Inscriere> Inscrieri        => Set<Inscriere>();    protected override void OnModelCreating(        ModelBuilder b)    {        b.Entity<Eveniment>()            .Property(e => e.Titlu)            .HasMaxLength(120);        b.Entity<Inscriere>()            .Property(i => i.Nume)            .HasMaxLength(80);    }}

Fiecare DbSet e o tabelă pe care o poți interoga și modifica. În OnModelCreating precizezi ce nu reiese din convenții, de exemplu lungimea maximă a textelor. Fără ea, un string devine longtext.

Contextul se înregistrează în Program.cs, cu șirul de conexiune citit din appsettings.json:

Program.cs, înainte de Build
var cs = builder.Configuration    .GetConnectionString("Mysql");builder.Services.AddDbContext<AppDbContext>(    o => o.UseMySql(cs,        new MySqlServerVersion(            new Version(8, 4))));
appsettings.json
{  "ConnectionStrings": {    "Mysql": "Server=localhost;Port=3306;Database=evenimente;User=root;Password=parola-locala"  },  "Logging": {    "LogLevel": {      "Default": "Information",      "Microsoft.AspNetCore": "Warning"    }  },  "AllowedHosts": "*"}

Parola stă aici doar pe calculatorul tău. Pe un server, o pui într-o variabilă de mediu: ConnectionStrings__Mysql înlocuiește valoarea din fișier.

Migrațiile: istoria bazei, în cod

terminal
dotnet ef migrations add Initialdotnet ef database update

Prima comandă compară clasele cu ultima stare cunoscută și scrie, în folderul Migrations, un fișier C# cu pașii necesari. A doua îi rulează pe MySQL. Din logul ei, partea esențială:

Din ieșirea lui dotnet ef database update

Applying migration '20261107222152_Initial'.
CREATE TABLE `Evenimente` (
    `Id` int NOT NULL AUTO_INCREMENT,
    `Titlu` varchar(120) CHARACTER SET utf8mb4 NOT NULL,
    `Data` datetime(6) NOT NULL,
    `Locuri` int NOT NULL,
    CONSTRAINT `PK_Evenimente` PRIMARY KEY (`Id`)
) CHARACTER SET=utf8mb4;
…
CONSTRAINT `FK_Inscrieri_Evenimente_EvenimentId` FOREIGN KEY (`EvenimentId`) REFERENCES `Evenimente` (`Id`) ON DELETE CASCADE
…
Done.

Tabela __EFMigrationsHistory ține minte ce migrații au rulat, deci update aplică doar ce lipsește. Migrațiile se comit în git, alături de cod: oricine clonează proiectul își face baza identică.

Capcană: ai creat migrația, dar n-ai aplicat-o

migrations add doar scrie fișierul. Dacă pornești aplicația înainte de database update, prima salvare cade cu 500. În log:

Microsoft.EntityFrameworkCore.DbUpdateException: An error occurred while saving the entity changes. See the inner exception for details.
 ---> MySqlConnector.MySqlException (0x80004005): Table 'evenimente.Evenimente' doesn't exist

Repară rulând dotnet ef database update. Verifică ce s-a aplicat cu dotnet ef migrations list: migrațiile neaplicate apar cu „(Pending)”.

Capcană: MySQL nu e pornit sau portul e greșit

Aplicația pornește fără probleme, pentru că se conectează abia la prima cerere care are nevoie de bază. Atunci primești:

System.InvalidOperationException: An exception has been raised that is likely due to a transient failure. Consider enabling transient error resiliency by adding 'EnableRetryOnFailure()' to the 'UseMySql' call.
 ---> MySqlConnector.MySqlException (0x80004005): Unable to connect to any of the specified MySQL hosts.

Repară verificând containerul cu docker ps și portul din șirul de conexiune. Sugestia cu EnableRetryOnFailure ajută la întreruperi scurte, nu la un server oprit.

Pasul 4 din 5

Verifică-te

Cinci întrebări despre proiectul de ateliere. După fiecare răspuns vezi imediat de ce e așa.

1 din 5 · Prezice rezultatul

Imediat după db.Evenimente.Add(e), ce valori au db.Entry(e).State și e.Id?

Răspuns: Added și 0.

Așa a afișat și programul de test: Added 0. Cheia o dă MySQL, la inserare, deci apare abia după SaveChangesAsync.

2 din 5 · Alege varianta

Adaugi în Eveniment proprietatea public string Oras { get; set; } = "";. Ce faci ca să apară coloana în MySQL?

Răspuns: o migrație nouă, apoi update.

Fără migrație nouă, update nu are nimic de aplicat. Fiecare schimbare de model devine o migrație cu nume, în ordine.

3 din 5 · Alege varianta

Ce devine în MySQL proprietatea EvenimentId din Inscriere?

Răspuns: o coloană cu cheie străină și un index.

Migrația a creat FK_Inscrieri_Evenimente_EvenimentId și IX_Inscrieri_EvenimentId. Doar proprietatea Eveniment, de navigare, nu devine coloană.

4 din 5 · Prezice rezultatul

Imediat după un SaveChangesAsync reușit, mai chemi o dată await db.SaveChangesAsync(), fără alte modificări. Ce întoarce?

Răspuns: 0, fără nicio comandă SQL.

SaveChangesAsync întoarce câte rânduri a scris. După prima salvare, atelierul e Unchanged, deci nu mai e nimic de trimis.

5 din 5 · Alege varianta

Cât trăiește un AppDbContext înregistrat cu AddDbContext?

Răspuns: o cerere HTTP.

AddDbContext îl înregistrează ca scoped: unul pe cerere. Un context nu e făcut pentru mai multe fire de execuție deodată, iar evidența lui ar crește fără limită dacă ar trăi cât aplicația.

Pasul 5 din 5

Ce ai învățat

Program.cs complet

Împreună cu Modele.cs și AppDbContext.cs din pasul 3, acesta e tot proiectul. Ruta GET citește toate atelierele cu ToListAsync. Repornește aplicația și cere lista: atelierele salvate sunt tot acolo.

Program.cs
using Microsoft.EntityFrameworkCore;var builder = WebApplication.CreateBuilder(args);var cs = builder.Configuration    .GetConnectionString("Mysql");builder.Services.AddDbContext<AppDbContext>(    o => o.UseMySql(cs,        new MySqlServerVersion(            new Version(8, 4))));var app = builder.Build();app.MapPost("/evenimente",    async (AppDbContext db) =>{    var e = new Eveniment    {        Titlu = "Atelier de robotică",        Data = new DateTime(2026, 12, 5),        Locuri = 12    };    db.Evenimente.Add(e);    await db.SaveChangesAsync();    return Results.Created(        $"/evenimente/{e.Id}", e);});app.MapGet("/evenimente",    async (AppDbContext db) =>        await db.Evenimente.ToListAsync());app.Run();

curl http://localhost:5207/evenimente, după repornire

[{"id":1,"titlu":"Atelier de robotică","data":"2026-12-05T00:00:00","locuri":12,"inscrieri":[]}]

Continuă cu