MyCodeSchool

Pasul 1 din 5

ASP.NET Core

Pasul 1 din 5 · Ce construiești

  • ASP.NET Core
  • Mediu
  • 13 minute

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:

al doilea terminal
curl -i -X POST \  http://localhost:5207/api/evenimente/1/inscrieri \  -H "Content-Type: application/json" \  -d '{"nume":"Ioana"}'
răspunsul
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ă.

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;public enum Rezultat { Ok, Inexistent, Plin }public interface IInscrieriService{    Task<(Rezultat, Inscriere?)> InscrieAsync(        int evenimentId, string nume);}public class InscrieriService(AppDbContext db)    : IInscrieriService{    public async 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 is null)            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


      

  1. Linia 15. Controllerul a validat corpul cererii și cheamă serviciul cu evenimentId 1 și numele „Matei”.
  2. 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(*).
  3. Linia 25. Atelierul există, deci trecem mai departe.
  4. Linia 27. 1 >= 2 e fals: mai e un loc.
  5. Linia 30. Înscrierea nouă primește doar cheia străină, EvenimentId. Nu e nevoie să încarci tot atelierul.
  6. Linia 36. INSERT în tabela Inscrieri. Matei primește Id 2.
  7. Linia 37. Serviciul întoarce rezultatul și înscrierea, iar controllerul le transformă în 201.
  8. Linia 15. Vine o nouă cerere, pentru Ioana, la același atelier. E un context nou și un serviciu nou, pentru o cerere nouă.
  9. Linia 17. Aceeași interogare găsește acum 2 înscrieri.
  10. Linia 27. 2 >= 2 e adevărat: atelierul e plin.
  11. Linia 28. Serviciul întoarce Plin, fără nicio excepție și fără să scrie nimic. Controllerul răspunde 409.
  12. 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 subțire, serviciul cu regula

Controllers/InscrieriController.cs
using Microsoft.AspNetCore.Mvc;using Microsoft.EntityFrameworkCore;[ApiController][Route("api/evenimente/{evenimentId:int}/inscrieri")]public class InscrieriController(    IInscrieriService serviciu, AppDbContext db)    : ControllerBase{    [HttpGet]    public async Task<List<InscriereDto>>        Toate(int evenimentId)        => await db.Inscrieri            .Where(i => i.EvenimentId == evenimentId)            .Select(i => new InscriereDto(i.Id, i.Nume))            .ToListAsync();    [HttpPost]    public async Task<ActionResult<InscriereDto>>        Inscrie(int evenimentId, InscriereNoua nou)    {        var (rezultat, i) = await serviciu            .InscrieAsync(evenimentId, nou.Nume);        return rezultat switch        {            Rezultat.Inexistent => NotFound(),            Rezultat.Plin => Problem(                title: "Atelierul e plin.",                statusCode: 409),            _ => Created(                $"{Request.Path}/{i!.Id}",                new InscriereDto(i.Id, i.Nume))        };    }}

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:

Dto.cs, la final
public record InscriereDto(int Id, string Nume);public class InscriereNoua{    [Required]    [StringLength(80, MinimumLength = 2)]    public string Nume { get; set; } = "";}

Injectarea dependențelor și durata de viață

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))));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
MetodaUn obiect nou
AddTransientla fiecare cerere a dependenței
AddScopedla fiecare cerere HTTP
AddSingletono 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.

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ă:

Program.cs, varianta greșită
builder.Services.AddSingleton<IInscrieriService,    InscrieriService>();
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…

EvenimenteController.cs, varianta greșită
[HttpGet("{id:int}/complet")]public async Task<Eveniment?> Complet(int id)    => await db.Evenimente        .Include(e => e.Inscrieri)        .FirstOrDefaultAsync(e => e.Id == id);
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

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ă:

GET /api/evenimente/1/inscrieri

[{"id":1,"nume":"Ana"},{"id":2,"nume":"Matei"}]

Continuă cu