ASP.NET Core: servicii, relații și reguli de business
În ultima parte a proiectului de ateliere adaugi înscrierile. Un atelier are un număr limitat de locuri: când s-a umplut, API-ul refuză politicos orice înscriere nouă. Atelierul de ceramică are 2 locuri, iar Ana și Matei s-au înscris deja:
HTTP/1.1 409 Conflict
Content-Type: application/problem+json; charset=utf-8
{"type":"https://tools.ietf.org/html/rfc9110#section-15.5.10","title":"Atelierul e plin.","status":409,"traceId":"00-34f5bee9ec55a666ae34a6d43c133a1d-d9419f12883d0300-00"}
409 Conflict înseamnă: cererea e corectă ca formă, dar intră în conflict cu starea datelor. Validarea din partea a doua nu putea prinde asta, pentru că răspunsul depinde de ce e deja în bază.
să muți regulile de business din controller într-un serviciu
să primești dependențele prin constructor, cu injectarea dependențelor
să alegi durata de viață potrivită: AddScoped, AddSingleton, AddTransient
să expui o relație unu la mulți prin rute imbricate, fără cicluri JSON
Pasul 2 din 5
Regula, rulată pentru două înscrieri
Serviciul de mai jos face înscrierea. Ana e deja înscrisă la atelierul cu 2 locuri. Urmărești înscrierea lui Matei, apoi pe a Ioanei.
Servicii/InscrieriService.cs
using Microsoft.EntityFrameworkCore;publicenum Rezultat { Ok, Inexistent, Plin }publicinterface IInscrieriService{ Task<(Rezultat, Inscriere?)> InscrieAsync(int evenimentId, string nume);}publicclassInscrieriService(AppDbContext db) : IInscrieriService{publicasync Task<(Rezultat, Inscriere?)> InscrieAsync(int evenimentId, string nume) {var ev = await db.Evenimente .Where(e => e.Id == evenimentId) .Select(e => new { e.Locuri, Ocupate = e.Inscrieri.Count }) .FirstOrDefaultAsync();if (ev isnull)return (Rezultat.Inexistent, null);if (ev.Ocupate >= ev.Locuri)return (Rezultat.Plin, null);var i = new Inscriere { EvenimentId = evenimentId, Nume = nume }; db.Inscrieri.Add(i);await db.SaveChangesAsync();return (Rezultat.Ok, i); }}
Stare
Răspunsuri
Linia 15. Controllerul a validat corpul cererii și cheamă serviciul cu evenimentId 1 și numele „Matei”.
Linia 17. O singură interogare aduce doar ce trebuie pentru regulă: numărul de locuri și câte înscrieri există. Numărarea se face în MySQL, cu COUNT(*).
Linia 25. Atelierul există, deci trecem mai departe.
Linia 27. 1 >= 2 e fals: mai e un loc.
Linia 30. Înscrierea nouă primește doar cheia străină, EvenimentId. Nu e nevoie să încarci tot atelierul.
Linia 36. INSERT în tabela Inscrieri. Matei primește Id 2.
Linia 37. Serviciul întoarce rezultatul și înscrierea, iar controllerul le transformă în 201.
Linia 15. Vine o nouă cerere, pentru Ioana, la același atelier. E un context nou și un serviciu nou, pentru o cerere nouă.
Linia 17. Aceeași interogare găsește acum 2 înscrieri.
Linia 27. 2 >= 2 e adevărat: atelierul e plin.
Linia 28. Serviciul întoarce Plin, fără nicio excepție și fără să scrie nimic. Controllerul răspunde 409.
Gata. Serviciul nu știe nimic despre HTTP. Aceeași regulă poate fi folosită și dintr-un test sau dintr-o aplicație de consolă.
Prezice răspunsul
Ioana încearcă la /api/evenimente/9/inscrieri, dar atelierul 9 nu există. Pe ce linie se oprește serviciul și ce primește ea?
Răspuns: linia 26, cu 404.
FirstOrDefaultAsync nu găsește nimic și dă null, deci serviciul întoarce Inexistent, iar controllerul îl transformă în NotFound(). Fără această verificare, INSERT-ul ar fi căzut pe cheia străină, cu 500.
Pasul 3 din 5
Servicii, dependențe, relații
Trei idei care țin un API ușor de schimbat pe măsură ce crește. La final, două erori pe care le întâlnește aproape oricine.
Controllerul face doar traducerea: HTTP spre serviciu, rezultat spre cod de stare. Problem construiește același tip de corp ca validarea, deci clientul primește erorile într-un singur format.
Ruta are parametrul în prefix, {evenimentId:int}, iar fiecare metodă îl primește după nume. Adresele arată relația: înscrierile atelierului 1 sunt la /api/evenimente/1/inscrieri. DTO-urile noi, în Dto.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))));builder.Services.AddScoped<IInscrieriService, InscrieriService>();builder.Services.AddControllers();var app = builder.Build();app.MapControllers();app.Run();
Controllerul cere un IInscrieriService, nu un InscrieriService. AddScoped spune ce clasă să construiască pentru interfață și cât să trăiască obiectul. Containerul vede că serviciul are nevoie de un AppDbContext și îl construiește și pe acela.
Duratele de viață ale serviciilor
Metoda
Un obiect nou
AddTransient
la fiecare cerere a dependenței
AddScoped
la fiecare cerere HTTP
AddSingleton
o singură dată, pentru toată aplicația
Regula: un serviciu nu poate trăi mai mult decât dependențele lui. Ce folosește un DbContext e cel mult scoped.
3
Relația, fără să încarci tot
Pentru regulă îți trebuiau două numere, nu atelierul cu toate înscrierile. De aceea serviciul folosește Select cu e.Inscrieri.Count, iar MySQL face numărătoarea:
SQL-ul din log, la fiecare înscriere
SELECT `e`.`Locuri`, (
SELECT COUNT(*)
FROM `Inscrieri` AS `i`
WHERE `e`.`Id` = `i`.`EvenimentId`) AS `Ocupate`
FROM `Evenimente` AS `e`
WHERE `e`.`Id` = @__evenimentId_0
LIMIT 1
Limita a ceea ce ai construit: două cereri simultane pentru ultimul loc pot trece amândouă de verificare înainte ca vreuna să salveze. Pentru un site cu trafic mare, verificarea și inserarea se pun într-o tranzacție.
Capcană: serviciu singleton care folosește DbContext
Pare o optimizare: un singur serviciu pentru toată aplicația. Dar contextul e scoped, unul pe cerere. În mediul Development, aplicația refuză să pornească:
Unhandled exception. System.AggregateException: Some services are not able to be constructed (Error while validating the service descriptor 'ServiceType: IInscrieriService Lifetime: Singleton ImplementationType: InscrieriService': Cannot consume scoped service 'AppDbContext' from singleton 'IInscrieriService'.)
---> System.InvalidOperationException: Error while validating the service descriptor 'ServiceType: IInscrieriService Lifetime: Singleton ImplementationType: InscrieriService': Cannot consume scoped service 'AppDbContext' from singleton 'IInscrieriService'.
---> System.InvalidOperationException: Cannot consume scoped service 'AppDbContext' from singleton 'IInscrieriService'.
Repară cu AddScoped. Verificarea aceasta rulează la pornire doar în Development. În producție, greșeala ar fi trecut neobservată, iar toate cererile ar fi împărțit același context.
Capcană: întorci entitatea cu Include
Vrei atelierul cu înscrierile lui și întorci direct entitatea. Atelierul are înscrieri, fiecare înscriere își are atelierul, care are înscrieri…
HTTP/1.1 500 Internal Server Error
System.Text.Json.JsonException: A possible object cycle was detected. This can either be due to a cycle or if the object depth is larger than the maximum allowed depth of 32. Consider using ReferenceHandler.Preserve on JsonSerializerOptions to support cycles. Path: $.Inscrieri.Eveniment.Inscrieri.Eveniment.Inscrieri.Eveniment…
Repară cu DTO-uri, ca în partea a doua: un EvenimentDto cu o listă de InscriereDto nu are drum înapoi. ReferenceHandler ascunde problema, dar îți umple JSON-ul cu $id și $ref.
Pasul 4 din 5
Verifică-te
Cinci întrebări despre înscrieri și servicii. După fiecare răspuns vezi imediat de ce e așa.
1 din 5 · Alege varianta
Unde stă regula „nu mai mult de Locuri înscrieri”?
Răspuns: în serviciu.
Atributele văd doar cererea, nu și câte înscrieri există deja. Controllerul ar putea face verificarea, dar atunci regula ar fi legată de HTTP și greu de refolosit sau de testat.
2 din 5 · Prezice răspunsul
După cele trei încercări din lecție, ce întoarce GET /api/evenimente/1?
Răspuns: „locuri”:2, „inscrisi”:2.
Încercarea Ioanei a fost respinsă înainte de Add, deci nu s-a scris nimic. Citirea atelierului nu are nicio legătură cu regula de înscriere: răspunsul e 200.
3 din 5 · Alege varianta
Ce câștigi când controllerul primește IInscrieriService, interfața, și nu clasa?
Răspuns: poți înlocui implementarea.
Schimbi o singură linie în Program.cs sau dai altă implementare într-un test. Înregistrarea rămâne obligatorie: containerul trebuie să știe ce clasă construiește pentru interfață.
4 din 5 · Prezice rezultatul
Înregistrezi serviciul cu AddSingleton și rulezi cu dotnet run, în Development. Ce se întâmplă?
Răspuns: nu pornește.
În Development, containerul verifică toate înregistrările la pornire și găsește un singleton care depinde de un serviciu scoped.
5 din 5 · Alege varianta
Ce cod de stare se potrivește când clientul vrea să se înscrie la un atelier plin?
Răspuns: 409 Conflict.
Cererea e corectă ca formă, deci nu e 400. Serverul nu a greșit, deci nu e 500. Starea datelor nu permite operația: exact sensul lui 409.
Pasul 5 din 5
Ce ai învățat
Regulile care depind de date stau într-un serviciu. Controllerul doar traduce între HTTP și serviciu.
Dependențele vin prin constructor, iar Program.cs spune ce clasă corespunde fiecărei interfețe.
Un serviciu care folosește DbContext e AddScoped, niciodată singleton.
Relațiile se expun prin rute imbricate și DTO-uri, nu prin entități cu Include.
Proiectul, la final
În cele trei lecții ai construit: Modele.cs și AppDbContext.cs, cu migrația inițială; Dto.cs; două controllere; Servicii/InscrieriService.cs și Program.cs. Modelul nu s-a schimbat din prima parte, deci nu a fost nevoie de o migrație nouă. Lista înscrierilor la atelierul de ceramică: