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ă:
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.
să descrii tabelele prin clase C#, cu entități și convenții
să legi aplicația de MySQL printr-un DbContext
să creezi tabelele cu migrații, nu cu SQL scris de mână
să urmărești ce face EF Core la Add și la SaveChangesAsync
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
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.
Linia 4. Un obiect C# obișnuit. EF Core nu știe de el: starea e Detached, iar Id e 0.
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.
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ă.
Linia 12. Răspunsul 201 conține noul Id și adresa atelierului.
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.
1
Entitățile: clase care devin tabele
Modele.cs
publicclassEveniment{publicint Id { get; set; }publicstring Titlu { get; set; } = "";public DateTime Data { get; set; }publicint Locuri { get; set; }public List<Inscriere> Inscrieri { get; set; } = new();}publicclassInscriere{publicint Id { get; set; }publicint EvenimentId { get; set; }public Eveniment? Eveniment { get; set; }publicstring 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.
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,newMySqlServerVersion(newVersion(8, 4))));
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.
3
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
Entitățile sunt clase C#. Convențiile fac din Id o cheie primară și din EvenimentId o cheie străină.
DbContext ține evidența entităților, iar AddDbContext îți dă câte unul nou pe fiecare cerere.
migrations add scrie pașii, database update îi aplică. Migrațiile se comit în git.
Add doar marchează. SQL-ul pleacă abia la SaveChangesAsync, iar cheia nouă apare după.
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,newMySqlServerVersion(newVersion(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":[]}]