...
Pregătire interviuri

100 de întrebări de interviu ASP.NET Core, cu răspunsuri

Întrebările despre ASP.NET Core care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs ASP.NET Core: primele 20 de lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 136 minde citit
Întrebări de interviu ASP.NET Core cu răspunsuri

La un interviu pentru un post de .NET backend, ASP.NET Core este verificat de obicei separat de limbajul C#: intervievatorii vor să vadă dacă înțelegi ce se întâmplă cu o cerere HTTP din momentul în care ajunge la Kestrel până când pleacă răspunsul. Întrebările de teorie (pipeline-ul de middleware, duratele de viață din dependency injection, rutarea și model binding-ul, configurarea) sunt amestecate cu fragmente de cod de tipul „ce răspunde endpoint-ul?”, „de ce nu pornește aplicația?” sau „unde e bug-ul?”, cu un exercițiu live (un mic API CRUD cu Minimal APIs sau cu un controller) și, des, cu o temă de casă despre care discutați apoi.

La nivel junior se verifică fundamentele: structura lui Program.cs, MapGet/MapPost, parametrii din rută și din query, codurile de status corecte, înregistrarea serviciilor, appsettings.json, controllerele cu [ApiController] și operațiile simple cu Entity Framework Core. La nivel mid, întrebările trec la consecințe: ordinea middleware-urilor, captive dependencies, IOptionsSnapshot față de IOptionsMonitor, ProblemDetails, filtrele, urmărirea entităților și erorile de concurență din DbContext, JWT și politicile de autorizare. Întrebările de nivel senior ating proiectarea: versionarea API-ului, idempotența, rezistența la erori, performanța și observabilitatea în producție.

Fiecare întrebare are un răspuns scurt, de spus în primele secunde, un răspuns detaliat cu cod și o notă despre ce urmărește intervievatorul. Exemplele sunt scrise pentru .NET 8 și .NET 9 (dotnet new web sau dotnet new webapi); rulează-le și modifică-le până înțelegi de ce se comportă așa. Întrebările despre limbajul C# sunt pe pagina dedicată C#, iar cele generale de .NET Developer (Git, Docker, SQL, HR) pe pagina meseriei; aici rămânem la ASP.NET Core.

Fundamente: host, Kestrel și Program.cs

1 Junior

Explică ce face fiecare linie din Program.cs de mai jos. De ce contează că serviciile se înregistrează înainte de Build()?

C#
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton<ICatalog, CatalogInMemorie>();

var app = builder.Build();

app.MapGet("/produse", (ICatalog catalog) => catalog.Toate());

app.Run();

Răspuns scurt: CreateBuilder pregătește configurarea, logging-ul și containerul de servicii, Build() creează aplicația și îngheață lista de servicii, MapGet înregistrează un endpoint, iar Run() pornește serverul Kestrel și blochează până la oprire.

Programul are două faze clare, iar intervievatorul vrea să vadă că le deosebești.

  • WebApplication.CreateBuilder(args) creează un WebApplicationBuilder: citește configurarea (appsettings.json, appsettings.{Mediu}.json, variabile de mediu, argumente), stabilește mediul (Development, Production), configurează logging-ul și pregătește builder.Services, colecția în care declari serviciile.
  • builder.Services.AddSingleton<ICatalog, CatalogInMemorie>() spune containerului: „când cineva cere ICatalog, dă-i o instanță CatalogInMemorie, aceeași pentru toată aplicația”.
  • builder.Build() construiește IServiceProvider-ul din lista de servicii și întoarce WebApplication. Din acest moment colecția de servicii este doar pentru citire.
  • app.MapGet(...) adaugă un endpoint: metoda HTTP, șablonul de rută și handler-ul. Parametrul ICatalog vine din DI, pentru că tipul este înregistrat.
  • app.Run() pornește Kestrel, ascultă pe URL-urile configurate și blochează firul principal până când aplicația primește semnalul de oprire.

Ordinea este impusă: serviciile se adaugă pe builder, middleware-ul și endpoint-urile pe app. Dacă încerci builder.Services.AddScoped<...>() după Build(), primești InvalidOperationException: The service collection cannot be modified because it is read-only., pentru că providerul a fost deja construit și nu mai poate afla de servicii noi.

În proiectele mari, Program.cs rămâne scurt: înregistrările se mută în metode de extensie (builder.Services.AddCatalog()), iar endpoint-urile în clase separate.

Ce urmărește intervievatorul: Verifică dacă înțelegi separarea dintre configurarea serviciilor și configurarea pipeline-ului. Mulți candidați recită liniile fără să știe ce se întâmplă la Build().

2 Junior

Ce conține un proiect creat cu dotnet new web și prin ce diferă de unul creat cu dotnet new webapi?

Răspuns scurt: Ambele folosesc SDK-ul Microsoft.NET.Sdk.Web, Program.cs, appsettings.json și Properties/launchSettings.json. web este un schelet gol cu un singur endpoint, iar webapi adaugă exemplul de API, documentul OpenAPI și fișierul .http pentru cereri de test.

dotnet new web creează cel mai mic proiect ASP.NET Core:

  • NumeProiect.csproj cu <Project Sdk="Microsoft.NET.Sdk.Web">; SDK-ul web aduce automat referința la framework-ul Microsoft.AspNetCore.App, deci nu instalezi pachete pentru Kestrel, rutare sau DI;
  • Program.cs cu MapGet("/", () => "Hello World!");
  • appsettings.json și appsettings.Development.json, citite automat de CreateBuilder;
  • Properties/launchSettings.json, folosit doar local de dotnet run, Visual Studio și Rider.

dotnet new webapi (în .NET 8 și 9) pornește de la același schelet, dar adaugă un endpoint de exemplu (/weatherforecast), suportul OpenAPI (AddOpenApi() și MapOpenApi() în .NET 9, Swashbuckle în .NET 8) și un fișier NumeProiect.http cu cereri pe care le trimiți direct din editor. Cu opțiunea --use-controllers primești varianta cu Controllers/ și AddControllers().

BASH
dotnet new web -n Magazin.Api
dotnet new webapi -n Magazin.Api --use-controllers

În csproj mai apar <Nullable>enable</Nullable> și <ImplicitUsings>enable</ImplicitUsings>. Al doilea adaugă using-uri globale specifice web-ului, de aceea poți scrie WebApplication sau Results fără niciun using sus în fișier.

Pentru un interviu e bine să spui ce ai ales în proiectul tău și de ce: web când vrei să controlezi totul de la zero, webapi când vrei rapid OpenAPI și structura standard.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai creat proiecte singur, nu doar ai deschis unul gata făcut. Un semn bun este să știi ce aduce Sdk.Web și ce face ImplicitUsings.

3 Junior

Ce este Properties/launchSettings.json? Este folosit și când aplicația rulează pe server?

Răspuns scurt: Este fișierul cu profilurile de pornire locală: URL-urile, mediul (ASPNETCORE_ENVIRONMENT) și dacă se deschide browserul. Îl citesc doar dotnet run, Visual Studio și Rider; nu se publică și nu are niciun efect pe server.

Un profil tipic arată așa:

JSON
{
  "profiles": {
    "http": {
      "commandName": "Project",
      "applicationUrl": "http://localhost:5080",
      "environmentVariables": { "ASPNETCORE_ENVIRONMENT": "Development" }
    },
    "https": {
      "commandName": "Project",
      "applicationUrl": "https://localhost:7080;http://localhost:5080",
      "environmentVariables": { "ASPNETCORE_ENVIRONMENT": "Development" }
    }
  }
}

Când rulezi dotnet run, se folosește primul profil cu commandName: Project (sau cel ales cu --launch-profile https). Valorile din profil devin variabile de mediu pentru proces: applicationUrl ajunge în ASPNETCORE_URLS, iar ASPNETCORE_ENVIRONMENT stabilește mediul. De aceea local aplicația este în Development și vezi pagina de excepții pentru dezvoltatori.

Fișierul nu face parte din dotnet publish. Pe server, în container sau în Azure App Service, mediul implicit este Production, iar URL-urile vin din variabile de mediu (ASPNETCORE_URLS, ASPNETCORE_HTTP_PORTS), din appsettings.json (secțiunea Kestrel:Endpoints) sau din argumentele liniei de comandă.

Greșeala clasică: cineva pune un connection string sau o cheie în environmentVariables din launchSettings, aplicația merge local, apoi pe server nu mai găsește valoarea. Pentru secrete locale folosești user secrets, iar pe server variabile de mediu sau un seif de secrete.

Ce urmărește intervievatorul: Verifică dacă știi de unde vine mediul Development și de ce aplicația se comportă altfel pe server. Răspunsul greșit tipic este că launchSettings configurează și producția.

4 Junior

Pe ce adresă ascultă aplicația dacă nu configurezi nimic? Care sunt modurile prin care schimbi portul?

Răspuns scurt: Fără configurare, Kestrel ascultă pe http://localhost:5000; imaginile Docker oficiale pentru .NET 8+ setează portul 8080. Îl schimbi cu ASPNETCORE_URLS sau ASPNETCORE_HTTP_PORTS, argumentul --urls, secțiunea Kestrel:Endpoints din configurare sau din cod.

Ai mai multe niveluri, de la cel mai simplu la cel mai explicit:

  • variabila de mediu ASPNETCORE_URLS=http://+:8080 (sau http://0.0.0.0:8080) ori, din .NET 8, ASPNETCORE_HTTP_PORTS=8080 și ASPNETCORE_HTTPS_PORTS;
  • argumentul de linie de comandă: dotnet Magazin.Api.dll --urls "http://localhost:6000";
  • din cod: app.Urls.Add("http://localhost:6000"), app.Run("http://localhost:6000") sau builder.WebHost.UseUrls(...);
  • configurarea Kestrel, cea mai completă, care permite și certificate:
JSON
{
  "Kestrel": {
    "Endpoints": {
      "Http": { "Url": "http://0.0.0.0:8080" },
      "Https": {
        "Url": "https://0.0.0.0:8443",
        "Certificate": { "Path": "cert.pfx", "Password": "..." }
      }
    }
  }
}

Dacă există Kestrel:Endpoints în configurare, ele au prioritate față de ASPNETCORE_URLS, iar la pornire vezi un avertisment că adresele din URLS sunt ignorate.

Două capcane frecvente. Prima: localhost acceptă doar conexiuni de pe aceeași mașină; într-un container trebuie să asculți pe + sau 0.0.0.0, altfel portul mapat nu răspunde. A doua: în Docker, imaginile mcr.microsoft.com/dotnet/aspnet:8.0 setează ASPNETCORE_HTTP_PORTS=8080, nu 80 ca în versiunile vechi, iar un EXPOSE 80 copiat dintr-un tutorial vechi face aplicația inaccesibilă.

Ce urmărește intervievatorul: Arată dacă ai pus o aplicație într-un container sau pe un server. Candidații fără experiență practică nu știu de diferența dintre localhost și 0.0.0.0.

5 Junior

Aplicația următoare se oprește la pornire cu o excepție. Ce mesaj apare și cum o repari?

C#
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

builder.Services.AddScoped<ServiciuComenzi>();

app.MapGet("/comenzi", (ServiciuComenzi s) => s.Toate());
app.Run();

Răspuns scurt: Apare InvalidOperationException: The service collection cannot be modified because it is read-only., pentru că serviciul este înregistrat după Build(). Mută AddScoped înainte de builder.Build().

builder.Build() ia lista din builder.Services, construiește IServiceProvider-ul și marchează colecția ca read-only. Orice Add... după acest punct aruncă imediat:

System.InvalidOperationException: The service collection cannot be modified because it is read-only.

Varianta corectă păstrează ordinea „servicii, apoi build, apoi pipeline”:

C#
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddScoped<ServiciuComenzi>();

var app = builder.Build();

app.MapGet("/comenzi", (ServiciuComenzi s) => s.Toate());
app.Run();

O variantă înrudită a aceleiași greșeli apare când ordinea e corectă, dar înregistrarea lipsește cu totul. Atunci aplicația nu pornește din alt motiv: ServiciuComenzi nu e serviciu cunoscut, așa că Minimal APIs îl consideră corpul cererii, iar la un MapGet primești la pornire mesajul „Body was inferred but the method does not allow inferred body parameters”.

Regula de lucru: builder este pentru ce are aplicația (servicii, configurare, logging), app este pentru cum tratează cererile (middleware, endpoint-uri). Dacă Program.cs crește, grupează înregistrările în metode de extensie pe IServiceCollection (AddModulComenzi()) și apelează-le toate înainte de Build().

Ce urmărește intervievatorul: Verifică dacă înțelegi ciclul de viață al lui WebApplicationBuilder. Candidații care au doar copiat cod nu pot explica de ce colecția devine read-only.

6 Junior

Care este diferența dintre app.Run(), await app.RunAsync() și app.Run(async context => ...)?

Răspuns scurt: app.Run() și await app.RunAsync() pornesc serverul și așteaptă oprirea, sincron sau asincron. app.Run(async context => ...) este altceva: adaugă un middleware terminal care răspunde la orice cerere ajunsă la el și nu pornește serverul.

Numele identic derutează, dar sunt două metode diferite.

WebApplication.Run() pornește host-ul: Kestrel începe să asculte, rulează serviciile găzduite și firul principal se blochează până la Ctrl+C sau SIGTERM. RunAsync() face același lucru, dar întoarce un Task, util când Program.cs folosește deja await (de exemplu pentru o migrare înainte de pornire). Mai există app.Run("http://localhost:6000"), care pornește pe un URL anume.

app.Run(RequestDelegate) este metoda de extensie RunExtensions.Run pe IApplicationBuilder: adaugă la finalul pipeline-ului un delegat care nu primește next, deci scurtcircuitează.

C#
var app = WebApplication.Create(args);

app.MapGet("/salut", () => "Salut");

app.Run(async context =>
{
    context.Response.StatusCode = 404;
    await context.Response.WriteAsync("Pagina nu există");
});

app.Run();   // abia aici pornește serverul

Dacă uiți ultimul app.Run(), programul configurează pipeline-ul și se termină imediat, fără să asculte pe vreun port. Dacă pui middleware-ul terminal înaintea altor app.Use(...), cele de după nu rulează niciodată.

Pentru răspunsul „nu am găsit nimic”, varianta modernă este app.MapFallback(...), care se integrează cu rutarea și nu interceptează cererile care au endpoint.

Ce urmărește intervievatorul: Verifică dacă deosebești pornirea host-ului de construirea pipeline-ului. Confuzia dintre cele două Run apare des la juniori.

Eroarea, în practică:404 Not Found: endpoint mapat după app.Run()

7 Mid

Ce s-a schimbat în .NET 6 prin trecerea de la Host.CreateDefaultBuilder cu clasa Startup la WebApplication? Cum ai migra un proiect vechi?

Răspuns scurt: WebApplication (minimal hosting) unește host-ul, ConfigureServices și Configure într-un singur fișier: serviciile pe builder.Services, pipeline-ul pe app. Generic host-ul rămâne dedesubt, iar clasa Startup încă merge, deci migrarea poate fi treptată.

Înainte de .NET 6, un proiect avea două fișiere:

C#
// Program.cs
Host.CreateDefaultBuilder(args)
    .ConfigureWebHostDefaults(web => web.UseStartup<Startup>())
    .Build().Run();

// Startup.cs
public class Startup
{
    public void ConfigureServices(IServiceCollection services) { ... }
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.UseRouting();
        app.UseEndpoints(e => e.MapControllers());
    }
}

Cu WebApplication, ConfigureServices devine cod pe builder.Services, iar Configure devine cod pe app. WebApplication implementează în același timp IApplicationBuilder (middleware) și IEndpointRouteBuilder (MapGet, MapControllers), iar UseRouting/UseEndpoints sunt adăugate automat. Configurarea și mediul sunt disponibile imediat, ca proprietăți (builder.Configuration, builder.Environment), fără callback-uri.

Diferențe care apar la migrare:

  • builder.Host și builder.WebHost există pentru API-urile vechi (UseSerilog, UseDefaultServiceProvider), dar unele setări (de exemplu schimbarea rădăcinii conținutului) se dau acum prin WebApplicationOptions;
  • metodele Configure cu parametri injectați devin servicii cerute din app.Services;
  • testele cu WebApplicationFactory<Startup> trec pe WebApplicationFactory<Program>, cu public partial class Program { }.

Migrarea sigură: păstrezi Startup și o apelezi manual (startup.ConfigureServices(builder.Services), apoi startup.Configure(app, app.Environment)), rulezi testele, apoi muți codul treptat.

Ce urmărește intervievatorul: Arată dacă ai lucrat și pe proiecte mai vechi, foarte frecvente în firme. Un candidat bun știe că generic host-ul nu a dispărut, doar API-ul de deasupra.

8 Mid

Ce sunt WebApplication.CreateSlimBuilder și CreateEmptyBuilder (.NET 8)? Când le folosești și ce pierzi față de CreateBuilder?

Răspuns scurt: Sunt variante mai mici ale builder-ului, gândite pentru Native AOT și pornire rapidă. CreateSlimBuilder păstrează configurarea JSON, variabilele de mediu și logging-ul în consolă, dar renunță la integrarea cu IIS, HTTPS și HTTP/3 implicite. CreateEmptyBuilder nu configurează aproape nimic.

CreateBuilder adaugă tot ce ai nevoie de obicei: toate sursele de configurare, mai mulți provideri de logging, integrarea cu IIS, HTTPS și HTTP/3 în Kestrel, validarea DI în Development, încărcarea startup-urilor găzduite. Toate acestea costă timp la pornire și dimensiune în binarul publicat.

CreateSlimBuilder(args) este punctul de plecare al șablonului dotnet new webapiaot:

C#
var builder = WebApplication.CreateSlimBuilder(args);

builder.Services.ConfigureHttpJsonOptions(o =>
    o.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonContext.Default));

var app = builder.Build();
app.MapGet("/produse", () => new[] { new Produs(1, "Mouse") });
app.Run();

record Produs(int Id, string Nume);

[JsonSerializable(typeof(Produs[]))]
partial class AppJsonContext : JsonSerializerContext { }

Dacă ai nevoie de HTTPS direct în Kestrel, îl adaugi explicit cu builder.WebHost.UseKestrelHttpsConfiguration().

CreateEmptyBuilder(new WebApplicationOptions { Args = args }) nu adaugă nici configurare, nici logging, nici măcar Kestrel: chemi singur builder.WebHost.UseKestrelCore() și adaugi ce îți trebuie.

Cu Native AOT mai apar constrângeri: fără reflection dinamic, deci JSON doar prin JsonSerializerContext generat la compilare, controllerele MVC nu sunt suportate, iar EF Core are suport limitat. Folosești aceste variante pentru microservicii mici, funcții serverless sau containere unde contează pornirea și memoria; pentru un API obișnuit, CreateBuilder rămâne alegerea corectă.

Ce urmărește intervievatorul: Verifică dacă urmărești noutățile din .NET 8 și înțelegi compromisurile Native AOT. Un răspuns bun spune și când nu merită.

9 Mid

Un client încarcă un fișier de 50 MB și primește 413 Payload Too Large. De unde vine limita și cum o schimbi doar pentru endpoint-ul de upload?

Răspuns scurt: Kestrel limitează implicit corpul unei cereri la 30.000.000 de octeți (MaxRequestBodySize). O ridici doar pe endpoint cu [RequestSizeLimit] sau .WithMetadata(new RequestSizeLimitAttribute(...)); pentru formulare multipart contează și FormOptions.MultipartBodyLengthLimit.

Kestrel are limite care protejează serverul de cereri abuzive. Cea pentru corp este KestrelServerLimits.MaxRequestBodySize, implicit 30.000.000 de octeți. O cerere mai mare este respinsă cu 413 înainte să ajungă la logica ta. Alte limite utile: RequestHeadersTimeout (30 de secunde), KeepAliveTimeout, MaxConcurrentConnections, MaxRequestHeadersTotalSize.

Ai trei niveluri de configurare:

C#
// global, pentru toată aplicația
builder.WebHost.ConfigureKestrel(o => o.Limits.MaxRequestBodySize = 10 * 1024 * 1024);

// doar pentru un endpoint Minimal API
app.MapPost("/fisiere", async (IFormFile fisier) => { ... })
   .WithMetadata(new RequestSizeLimitAttribute(100 * 1024 * 1024))
   .DisableAntiforgery();

// într-un controller
[HttpPost, RequestSizeLimit(100_000_000)]
public IActionResult Incarca(IFormFile fisier) { ... }

Pentru multipart/form-data mai există FormOptions.MultipartBodyLengthLimit (implicit 128 MB), configurat cu builder.Services.Configure<FormOptions>(...).

Nu e suficient să schimbi doar aplicația dacă în față stă un proxy: IIS are maxAllowedContentLength (tot 30.000.000 implicit), nginx are client_max_body_size (1 MB implicit), iar unele servicii cloud au limite proprii. Eroarea poate veni din oricare.

Regula de design: nu ridica limita global. Fișierele mari le primești pe un endpoint dedicat, le scrii în flux (Request.Body sau MultipartReader), nu le încarci întregi în memorie, sau le trimiți direct într-un storage cu un URL presemnat.

Ce urmărește intervievatorul: Verifică experiența cu probleme reale de producție și dacă știi că limitele există pe mai multe straturi. Ridicarea limitei globale fără motiv este un semnal slab.

10 Senior

Aplicația rulează în spatele unui reverse proxy (Nginx sau un load balancer) care face terminarea TLS. Redirecturile generate de aplicație au http:// în loc de https://, iar în loguri toate cererile par să vină de la aceeași adresă IP. De ce și cum repari?

Răspuns scurt: Kestrel vede conexiunea de la proxy, nu de la client: schema e http, IP-ul e al proxy-ului. Proxy-ul trimite datele reale în antetele X-Forwarded-For și X-Forwarded-Proto, iar UseForwardedHeaders le aplică pe HttpContext, doar pentru proxy-uri de încredere.

Când un proxy face terminarea TLS, clientul vorbește HTTPS cu proxy-ul, iar proxy-ul deschide o conexiune HTTP simplă către Kestrel. Din punctul de vedere al aplicației, cererea a venit pe http, de la IP-ul proxy-ului. De aceea Request.Scheme este http, Url-urile absolute și redirecturile (inclusiv cele de la autentificare) folosesc http://, UseHttpsRedirection poate intra în buclă, iar Connection.RemoteIpAddress este mereu același.

Proxy-ul pune informația originală în antete: X-Forwarded-For (IP-ul clientului), X-Forwarded-Proto (https) și X-Forwarded-Host. Middleware-ul Forwarded Headers le citește și rescrie HttpContext:

C#
using Microsoft.AspNetCore.HttpOverrides;

builder.Services.Configure<ForwardedHeadersOptions>(o =>
{
    o.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
    o.KnownProxies.Add(System.Net.IPAddress.Parse("10.0.0.5"));
});

var app = builder.Build();
app.UseForwardedHeaders();   // primul, înaintea HSTS, autentificării, logării

Detalii care contează:

  • ordinea: UseForwardedHeaders trebuie pus foarte devreme, altfel middleware-urile de dinainte văd valorile greșite;
  • încrederea: implicit sunt acceptate doar proxy-urile de pe loopback. Dacă proxy-ul e în altă rețea, adaugi KnownProxies sau KnownNetworks; dacă ai accepta antetele de la oricine, un client ar putea să-și falsifice IP-ul (de exemplu ca să ocolească rate limiting-ul);
  • ForwardLimit (implicit 1) contează când sunt mai multe proxy-uri în lanț;
  • pe IIS cu modulul ASP.NET Core și pe unele platforme de hosting, integrarea face asta automat; în containere, de obicei nu.

Ce urmărește intervievatorul: Verifică dacă înțelegi că aplicația vede doar conexiunea TCP directă și dacă știi riscul de securitate al antetelor acceptate fără verificare. Greșeala tipică este să pui middleware-ul prea târziu sau să accepți antetele de la orice sursă.

Minimal APIs și rutare

11 Junior

Ce răspunde aplicația la fiecare cerere?

C#
app.MapGet("/produse/{id:int}", (int id) => $"Produsul {id}");
GET /produse/7
GET /produse/abc
GET /produse/99999999999

Răspuns scurt: /produse/7 răspunde 200 cu Produsul 7. Celelalte două răspund 404, nu 400: constrângerea int face parte din potrivirea rutei, iar abc și un număr prea mare pentru int nu se potrivesc cu ruta.

Constrângerea {id:int} este verificată de rutare, înainte ca handler-ul să fie ales. Pentru abc, int.TryParse eșuează, deci ruta nu se potrivește; pentru 99999999999, valoarea depășește int.MaxValue și se întâmplă același lucru. Dacă nicio altă rută nu se potrivește, rezultatul este 404 cu corp gol.

Comportamentul diferă dacă scoți constrângerea:

C#
app.MapGet("/produse/{id}", (int id) => $"Produsul {id}");

Acum orice segment se potrivește cu ruta, iar conversia în int o face model binding-ul. Pentru abc primești 400 Bad Request, iar în Development corpul conține Failed to bind parameter "int id" from "abc".

Ce alegi depinde de intenție:

  • constrângerea (int, guid, alpha, long) e potrivită când vrei să deosebești rute: /produse/{id:int} și /produse/{slug} pot coexista;
  • fără constrângere, clientul primește un 400 care îi spune că a trimis o valoare greșită, ceea ce e mai informativ decât un 404.

O constrângere nu este validare. {id:min(1)} dă tot 404 pentru 0, deși clientul ar merita un 400 cu un mesaj. Validarea regulilor de business o faci în handler sau într-un endpoint filter.

Ce urmărește intervievatorul: Verifică dacă știi unde se termină rutarea și unde începe binding-ul. Mulți candidați presupun că o valoare greșită dă mereu 400.

Eroarea, în practică:404 Not Found din cauza constrângerii de rutăFailed to bind parameter "int x" from "..."

12 Junior

Ce endpoint răspunde la fiecare dintre cererile de mai jos?

C#
app.MapGet("/produse/nou", () => "formular");
app.MapGet("/produse/{id:int}", (int id) => $"id {id}");
app.MapGet("/produse/{slug}", (string slug) => $"slug {slug}");
app.MapGet("/produse/{**rest}", (string rest) => $"rest {rest}");
GET /produse/nou
GET /produse/42
GET /produse/mouse-gaming
GET /produse/mouse/recenzii

Răspuns scurt: Pe rând: formular, id 42, slug mouse-gaming, rest mouse/recenzii. Ordinea în care scrii MapGet nu contează: rutarea alege după precedență, segmentele fixe înaintea parametrilor cu constrângeri, apoi parametrii simpli, iar catch-all-ul ultimul.

Rutarea din ASP.NET Core (endpoint routing) nu ia prima rută potrivită în ordinea înregistrării, ca în unele framework-uri. Construiește un arbore de decizie și, când mai multe rute se potrivesc, o alege pe cea mai specifică:

  • /produse/nou se potrivește cu toate patru, dar segmentul literal nou are cea mai mare precedență;
  • /produse/42 se potrivește cu {id:int}, {slug} și catch-all; parametrul cu constrângere câștigă în fața celui fără;
  • /produse/mouse-gaming nu trece de int, deci rămâne {slug};
  • /produse/mouse/recenzii are două segmente după produse; doar {**rest} acceptă mai multe segmente, iar valoarea lui este mouse/recenzii.

Diferența dintre {*rest} și {**rest} apare la generarea de link-uri: cu două stele, / din valoare rămâne /, cu o stea devine %2F. La potrivire se comportă la fel.

Problema apare când două rute au aceeași precedență, de exemplu {slug} și {nume} pe același prefix: rutarea nu le poate deosebi și cererea se termină cu AmbiguousMatchException (500). Dacă ai nevoie de o ordine explicită, există .WithOrder(n) în Minimal APIs și Order pe atributele din controllere, dar de obicei e un semn că rutele trebuie reproiectate.

Ce urmărește intervievatorul: Verifică dacă știi cum se rezolvă conflictele între rute. Răspunsul „câștigă prima rută scrisă” este greșit în ASP.NET Core.

Eroarea, în practică:AmbiguousMatchException: matched multiple endpoints

13 Junior

Scrie cu MapGroup un grup /api/produse cu trei endpoint-uri (listă, după id, adăugare). Ce câștigi față de a scrie prefixul la fiecare rută?

Răspuns scurt: MapGroup("/api/produse") întoarce un RouteGroupBuilder pe care înregistrezi rutele relative. Câștigi un singur loc pentru prefix și pentru convenții comune: autorizare, tag-uri OpenAPI, filtre, rate limiting, aplicate tuturor endpoint-urilor din grup.

C#
var produse = app.MapGroup("/api/produse")
    .WithTags("Produse")
    .RequireAuthorization();

produse.MapGet("/", (ICatalog c) => c.Toate());

produse.MapGet("/{id:int}", (int id, ICatalog c) =>
    c.Gaseste(id) is { } p ? Results.Ok(p) : Results.NotFound());

produse.MapPost("/", (ProdusNou date, ICatalog c) =>
{
    var p = c.Adauga(date);
    return Results.Created($"/api/produse/{p.Id}", p);
});

Rutele finale sunt GET /api/produse, GET /api/produse/{id} și POST /api/produse. Toate trei cer un utilizator autentificat și apar sub tag-ul „Produse” în documentația OpenAPI.

Grupurile se pot imbrica: var v1 = app.MapGroup("/api/v1"); var admin = v1.MapGroup("/admin").RequireAuthorization("Admin");. Convențiile se adună de la exterior la interior, iar pe un endpoint anume le poți completa sau anula (.AllowAnonymous() pe un GET public din grup).

Avantaje practice:

  • nu repeți prefixul, deci nu apar rute scrise greșit (/api/produs/ într-un loc, /api/produse/ în altul);
  • regulile de securitate nu se uită la un endpoint nou: dacă îl adaugi în grup, le moștenește;
  • poți muta un modul întreg într-o metodă de extensie care primește grupul.

Un detaliu: "/" din grup duce la /api/produse fără slash final. Dacă un client cere /api/produse/, rutarea îl tratează la fel, deoarece slash-ul final este ignorat la potrivire.

Ce urmărește intervievatorul: Verifică dacă ai scris Minimal APIs mai mari decât un exemplu. Un candidat bun pomenește că regulile puse pe grup protejează și endpoint-urile adăugate ulterior.

14 Junior

Cum faci un parametru de rută opțional sau cu valoare implicită? Când alegi asta și când query string-ul?

C#
app.MapGet("/rapoarte/{an:int}/{luna:int?}", (int an, int? luna) => ...);
app.MapGet("/blog/{pagina:int=1}", (int pagina) => ...);

Răspuns scurt: {luna?} face segmentul opțional, iar handler-ul trebuie să accepte lipsa lui (int? luna sau o valoare implicită). {pagina=1} pune o valoare implicită direct în rută. Folosește ruta pentru identitatea resursei și query string-ul pentru filtre, sortare și paginare.

Cu prima rută, GET /rapoarte/2026 dă an = 2026 și luna = null, iar GET /rapoarte/2026/3 dă luna = 3. Dacă parametrul C# ar fi int luna fără valoare implicită, lipsa segmentului ar produce un 400 în loc de null, pentru că un int simplu este obligatoriu.

A doua rută răspunde la /blog cu pagina = 1 și la /blog/3 cu pagina = 3. Același efect îl obții cu {pagina:int?} și int pagina = 1 în handler; varianta din rută ajută și la generarea link-urilor, unde valoarea implicită poate fi omisă.

Reguli de rutare: un segment opțional poate fi doar ultimul (sau urmat doar de alte opționale), iar parametrii cu valoare implicită nu pot fi urmați de segmente obligatorii.

Alegerea dintre rută și query:

  • ruta descrie ce resursă ceri: /clienti/15/comenzi/7. Un segment opțional e justificat când formează o ierarhie naturală (an, apoi lună);
  • query string-ul descrie cum o ceri: /produse?categorie=mouse&sort=pret&pagina=2. Filtrele se combină liber, se pot omite oricare și nu schimbă identitatea resursei.
C#
app.MapGet("/produse", (string? categorie, string sort = "nume", int pagina = 1) => ...);

Paginarea pusă în rută (/produse/pagina/2) se întâlnește la site-uri, din motive de SEO; la un API JSON, query string-ul este convenția obișnuită.

Ce urmărește intervievatorul: Verifică proiectarea URL-urilor, nu doar sintaxa. Greșeala tipică este parametrul int neopțional în handler pentru un segment opțional.

15 Junior

Aplicația pornește, dar GET /clienti/ana răspunde 500. De ce?

C#
app.MapGet("/clienti/{id}", (string id) => $"după id: {id}");
app.MapGet("/clienti/{email}", (string email) => $"după email: {email}");

Răspuns scurt: Cele două rute au aceeași formă și aceeași precedență, deci rutarea nu poate alege și aruncă AmbiguousMatchException: The request matched multiple endpoints. Eroarea apare la prima cerere potrivită, nu la pornire. Deosebește rutele prin constrângeri sau segmente fixe.

Numele parametrului nu contează la potrivire: pentru rutare, ambele șabloane înseamnă „/clienti/ urmat de un segment oarecare”. Când vine cererea, ambele endpoint-uri sunt candidate cu același scor, iar middleware-ul de rutare aruncă:

Microsoft.AspNetCore.Routing.Matching.AmbiguousMatchException:
The request matched multiple endpoints. Matches:

HTTP: GET /clienti/{id}
HTTP: GET /clienti/{email}

Aplicația pornește normal, pentru că arborele de rute este construit leneș și conflictul se descoperă doar când o cerere chiar se potrivește cu amândouă. De aceea problema scapă ușor de testele care nu ating ruta respectivă.

Soluții, în ordinea preferinței:

C#
// 1. segmente diferite: cel mai clar pentru client
app.MapGet("/clienti/{id:int}", (int id) => ...);
app.MapGet("/clienti/email/{email}", (string email) => ...);

// 2. constrângere care separă valorile
app.MapGet("/clienti/{id:guid}", (Guid id) => ...);
app.MapGet("/clienti/{email:regex(^[^@]+@[^@]+$)}", (string email) => ...);

// 3. un singur endpoint care decide singur
app.MapGet("/clienti/{cheie}", (string cheie) => cheie.Contains('@') ? ... : ...);

Aceeași eroare apare în controllere când două acțiuni au același verb și aceeași rută, de exemplu două [HttpGet] fără șablon în același controller. Un test de integrare care cere fiecare rută măcar o dată prinde aceste conflicte înainte de producție.

Ce urmărește intervievatorul: Verifică dacă înțelegi că numele parametrilor nu deosebesc rutele și că eroarea e la rulare. Candidații slabi caută problema în handler.

Eroarea, în practică:AmbiguousMatchException: matched multiple endpoints

16 Mid

Un coleg validează vârsta clientului direct în rută: /clienti/{varsta:range(18,120)}. Ce problemă are această abordare?

Răspuns scurt: Constrângerile de rută nu sunt validare: o valoare în afara intervalului face ruta să nu se potrivească, deci clientul primește 404 fără explicație, în loc de un 400 cu mesaj. Constrângerile servesc la deosebirea rutelor; regulile de business se validează în handler sau într-un filtru.

Pentru GET /clienti/15, rutarea verifică range(18,120), constrângerea pică, ruta este eliminată și, în lipsa alteia, răspunsul este 404 Not Found cu corp gol. Clientul API-ului înțelege „resursa nu există”, nu „ai trimis o vârstă invalidă”. Documentația ASP.NET Core spune explicit să nu folosești constrângerile pentru validarea datelor de intrare.

Mai sunt două probleme: regula de business ajunge ascunsă în șirul rutei, unde nimeni nu o caută, și nu poate fi testată sau refolosită separat.

Varianta corectă păstrează în rută doar tipul și pune regula în cod, cu un răspuns standard:

C#
app.MapGet("/clienti/{varsta:int}", (int varsta) =>
{
    if (varsta is < 18 or > 120)
        return Results.ValidationProblem(new Dictionary<string, string[]>
        {
            ["varsta"] = ["Vârsta trebuie să fie între 18 și 120."]
        });

    return Results.Ok(...);
});

Răspunsul este 400 cu application/problem+json și câmpul errors, pe care un frontend îl poate afișa lângă câmpul corect.

Unde au sens constrângerile: int/guid ca să separi /produse/{id:int} de /produse/{slug}, alpha sau regex pentru formate de URL fixe, length pentru coduri cu lungime cunoscută. Constrângerile regex sunt evaluate la fiecare cerere, deci păstrează-le simple.

Ce urmărește intervievatorul: Verifică dacă deosebești potrivirea rutei de validarea datelor și dacă te gândești la clientul API-ului. Un candidat bun pomenește diferența 404 față de 400.

Eroarea, în practică:404 Not Found din cauza constrângerii de rutăThe constraint reference 'x' could not be resolved

17 Mid

Scrie un endpoint filter care respinge cu 400 orice ProdusNou cu prețul negativ. În ce ordine rulează mai multe filtre pe același endpoint?

Răspuns scurt: Un filtru se adaugă cu .AddEndpointFilter(async (ctx, next) => ...), citește argumentele cu ctx.GetArgument<T>(index) și fie întoarce un rezultat (scurtcircuitează), fie cheamă next(ctx). Filtrele rulează în ordinea adăugării la intrare și în ordine inversă la ieșire, ca middleware-ul.

C#
app.MapPost("/produse", (ProdusNou p, ICatalog c) => Results.Ok(c.Adauga(p)))
   .AddEndpointFilter(async (ctx, next) =>
   {
       var p = ctx.GetArgument<ProdusNou>(0);
       if (p.Pret < 0)
           return Results.ValidationProblem(new Dictionary<string, string[]>
           {
               ["pret"] = ["Prețul nu poate fi negativ."]
           });

       return await next(ctx);
   });

record ProdusNou(string Nume, decimal Pret);

Filtrul rulează după model binding, deci argumentele sunt deja convertite, și înaintea handler-ului. GetArgument<T>(0) ia primul parametru al handler-ului; indexul depinde de ordinea parametrilor, așa că un filtru refolosibil caută mai sigur după tip: ctx.Arguments.OfType<ProdusNou>().FirstOrDefault().

Pentru refolosire, filtrul devine o clasă:

C#
class FiltruValidare<T> : IEndpointFilter where T : IValidabil
{
    public async ValueTask<object?> InvokeAsync(EndpointFilterInvocationContext ctx, EndpointFilterDelegate next)
    {
        var model = ctx.Arguments.OfType<T>().FirstOrDefault();
        if (model is not null && model.Valideaza() is { Count: > 0 } erori)
            return Results.ValidationProblem(erori);
        return await next(ctx);
    }
}

Ordinea: cu .AddEndpointFilter(A).AddEndpointFilter(B), se execută A înainte, B înainte, handler-ul, B după, A după. Filtrele puse pe un MapGroup se execută înaintea celor de pe endpoint. Diferența față de middleware: filtrul are acces la argumentele deja legate și rulează doar pentru endpoint-ul lui, nu pentru toate cererile.

Ce urmărește intervievatorul: Verifică dacă știi mecanismul de extensie specific Minimal APIs și cum diferă de middleware. Greșeala frecventă este indexul greșit la GetArgument.

18 Mid

Cum generezi în Minimal APIs URL-ul unei resurse create, fără să scrii ruta de mână în Location? Ce rol au WithName și LinkGenerator?

Răspuns scurt: Dai un nume endpoint-ului de citire cu .WithName("ProdusDupaId"), apoi folosești Results.CreatedAtRoute("ProdusDupaId", new { id }, produs) sau LinkGenerator.GetPathByName(...). URL-ul este construit din șablonul rutei, deci rămâne corect dacă ruta se schimbă.

C#
app.MapGet("/api/produse/{id:int}", (int id, ICatalog c) =>
        c.Gaseste(id) is { } p ? Results.Ok(p) : Results.NotFound())
   .WithName("ProdusDupaId");

app.MapPost("/api/produse", (ProdusNou date, ICatalog c) =>
{
    var p = c.Adauga(date);
    return Results.CreatedAtRoute("ProdusDupaId", new { id = p.Id }, p);
});

Răspunsul este 201 Created cu Location: http://localhost:5080/api/produse/4, construit din cerere (schemă, host) și din șablonul rutei numite. Dacă mâine ruta devine /api/v2/produse/{id:int}, link-ul se actualizează singur.

Când ai nevoie de URL în altă parte (de exemplu un link într-un email trimis dintr-un serviciu), injectezi LinkGenerator:

C#
app.MapGet("/comenzi/{id:int}/factura", (int id, LinkGenerator links, HttpContext ctx) =>
{
    var cale = links.GetPathByName("ProdusDupaId", new { id = 5 });          // /api/produse/5
    var absolut = links.GetUriByName(ctx, "ProdusDupaId", new { id = 5 });   // http://.../api/produse/5
    return new { cale, absolut };
});

Valorile care nu apar în rută devin query string (new { id = 5, tab = "recenzii" } dă /api/produse/5?tab=recenzii). Dacă numele nu există sau lipsește o valoare obligatorie, metodele întorc null, nu aruncă; un test care verifică Location prinde asta.

Numele trebuie să fie unice în toată aplicația. Două endpoint-uri cu același WithName produc o eroare de tip „duplicate endpoint name” când rutarea își construiește datele. WithName setează și operationId în documentul OpenAPI, deci numele contează și pentru clienții generați.

Ce urmărește intervievatorul: Verifică dacă știi să respecți convenția REST pentru 201 fără URL-uri scrise de mână. Un candidat bun pomenește și efectul asupra OpenAPI.

Eroarea, în practică:No route matches the supplied values

19 Mid

Ai 40 de endpoint-uri Minimal API într-un singur Program.cs. Cum ai organiza codul ca să rămână ușor de citit și de testat?

Răspuns scurt: Grupezi endpoint-urile pe module, fiecare într-o clasă statică cu o metodă de extensie pe IEndpointRouteBuilder (app.MapProduse()), iar handler-ele devin metode statice cu nume, care întorc TypedResults. Program.cs rămâne doar cu înregistrarea modulelor.

O structură care se folosește des:

C#
// Program.cs
app.MapProduse();
app.MapComenzi();

// Produse/ProduseEndpoints.cs
public static class ProduseEndpoints
{
    public static RouteGroupBuilder MapProduse(this IEndpointRouteBuilder app)
    {
        var g = app.MapGroup("/api/produse").WithTags("Produse");
        g.MapGet("/", Lista);
        g.MapGet("/{id:int}", DupaId).WithName("ProdusDupaId");
        g.MapPost("/", Adauga).AddEndpointFilter<FiltruValidare<ProdusNou>>();
        return g;
    }

    public static async Task<Ok<List<Produs>>> Lista(ICatalog c) =>
        TypedResults.Ok(await c.ToateAsync());

    public static async Task<Results<Ok<Produs>, NotFound>> DupaId(int id, ICatalog c) =>
        await c.GasesteAsync(id) is { } p ? TypedResults.Ok(p) : TypedResults.NotFound();

    public static async Task<Created<Produs>> Adauga(ProdusNou date, ICatalog c)
    {
        var p = await c.AdaugaAsync(date);
        return TypedResults.Created($"/api/produse/{p.Id}", p);
    }
}

Ce câștigi:

  • fiecare modul este un fișier cu o responsabilitate, iar Program.cs arată toată aplicația în câteva linii;
  • handler-ele sunt metode obișnuite, deci le testezi unitar fără server: var r = await ProduseEndpoints.DupaId(9, catalogFals); Assert.IsType<NotFound>(r.Result);;
  • tipurile TypedResults documentează automat răspunsurile în OpenAPI.

Organizarea pe funcționalități (Produse/, Comenzi/, cu endpoint-uri, DTO-uri și servicii împreună) scalează mai bine decât foldere pe tipuri tehnice. Există și biblioteci care automatizează modelul (Carter, FastEndpoints), dar o metodă de extensie pe modul acoperă majoritatea proiectelor.

Ce urmărește intervievatorul: Verifică dacă ai dus Minimal APIs dincolo de exemple și te gândești la testare. Un semnal slab este concluzia că Minimal APIs nu se pot folosi la proiecte mari.

20 Senior

Scrie un middleware care scrie în log doar cererile către endpoint-urile marcate cu .WithMetadata(new Auditat()). Cum află middleware-ul ce endpoint va rula?

Răspuns scurt: Rutarea alege endpoint-ul la începutul pipeline-ului și îl pune pe HttpContext. Orice middleware de după rutare îl citește cu context.GetEndpoint() și îi inspectează metadatele cu Metadata.GetMetadata<Auditat>(), înainte ca endpoint-ul să ruleze.

Endpoint routing are două etape: middleware-ul de rutare (UseRouting) potrivește cererea și setează endpoint-ul ales, iar middleware-ul de endpoint de la finalul pipeline-ului îl execută. Tot ce stă între ele vede deja decizia. Exact așa funcționează UseAuthorization, CORS-ul sau rate limiting-ul: citesc metadatele endpoint-ului ([Authorize], politici) și decid înainte de handler.

C#
var app = builder.Build();

app.UseRouting();
app.Use(async (context, next) =>
{
    var audit = context.GetEndpoint()?.Metadata.GetMetadata<Auditat>();
    if (audit is not null)
        app.Logger.LogInformation("Audit {Metoda} {Cale} de {Utilizator}",
            context.Request.Method, context.Request.Path, context.User.Identity?.Name ?? "anonim");
    await next(context);
});

app.MapDelete("/produse/{id:int}", (int id) => Results.NoContent())
   .WithMetadata(new Auditat());
app.MapGet("/produse", () => "lista");

app.Run();

sealed class Auditat;

Detalii care contează:

  • WebApplication adaugă UseRouting automat la începutul pipeline-ului; dacă îl chemi explicit, poziția lui contează. Un middleware pus înainte de UseRouting primește null din GetEndpoint();
  • metadatele pot fi orice obiect: atribute de pe controllere, obiecte puse cu WithMetadata, convenții pe grupuri. GetOrderedMetadata<T>() le dă pe toate, de la grup la endpoint;
  • context.GetEndpoint()?.DisplayName și RoutePattern (pe RouteEndpoint) ajută la loguri și metrici agregate pe rută, nu pe URL-ul concret, ca să nu explodeze numărul de serii.

Abordarea e mai bună decât o listă de căi în middleware: regula stă lângă endpoint și nu se desincronizează când se schimbă ruta.

Ce urmărește intervievatorul: Verifică înțelegerea internă a endpoint routing-ului și a metadatelor, baza pe care stau autorizarea și CORS. Seniorii pot explica de ce contează poziția lui UseRouting.

Model binding, rezultate și HTTP

Exersează capitolul cu exerciții reale: Curs ASP.NET Core online →
21 Junior

De unde ia Minimal APIs valoarea fiecărui parametru, fără niciun atribut?

C#
builder.Services.AddScoped<ICatalog, Catalog>();
...
app.MapPost("/magazine/{magazinId:int}/produse",
    (int magazinId, bool notifica, ProdusNou produs, ICatalog catalog,
     HttpContext ctx, CancellationToken ct) => ...);

Răspuns scurt: magazinId din rută (numele se potrivește cu șablonul), notifica din query string (tip simplu), produs din corpul JSON (tip complex), catalog din DI (tip înregistrat), iar HttpContext și CancellationToken sunt tipuri speciale, furnizate de framework.

Minimal APIs inferă sursa fiecărui parametru, în ordinea următoare:

1. atributele explicite au prioritate: [FromRoute], [FromQuery], [FromHeader], [FromBody], [FromForm], [FromServices], [AsParameters]; 2. tipurile speciale: HttpContext, HttpRequest, HttpResponse, CancellationToken (anulat când clientul închide conexiunea), ClaimsPrincipal, IFormFile/IFormFileCollection (din formular); 3. un tip cu BindAsync static se leagă singur din cerere; 4. un parametru al cărui nume apare în șablonul rutei vine din rută; 5. tipurile simple (cele cu TryParse: int, bool, Guid, DateOnly, enum-uri) vin din query string; 6. un tip înregistrat în DI vine din servicii; 7. orice alt tip complex este considerat corpul cererii (JSON), iar un endpoint poate avea un singur parametru din corp.

Pentru cererea POST /magazine/3/produse?notifica=true cu corp JSON, magazinId = 3, notifica = true, iar produs este deserializat din JSON (nume de proprietăți case-insensitive).

Capcanele vin din inferență: dacă uiți să înregistrezi ICatalog, regula 6 nu se aplică și ajungi la regula 7: endpoint-ul ar avea doi parametri din corp, iar aplicația refuză să pornească. La un MapGet, un tip complex nerecunoscut dă eroarea „Body was inferred but the method does not allow inferred body parameters”. Atributele explicite ([FromServices], [FromBody]) fac intenția clară și transformă aceste ghicitori în erori ușor de înțeles.

Ce urmărește intervievatorul: Verifică dacă știi regulile de inferență, nu doar atributele. Este una dintre puținele întrebări unde intersecția cu binding-ul general e acceptată, pentru că se cere ordinea exactă.

Eroarea, în practică:Implicit body inferred ... but no body was providedBody was inferred but the method does not allow ...

22 Junior

Endpoint-ul de mai jos primește trei cereri greșite. Ce cod de status primește clientul la fiecare și de ce?

C#
app.MapPost("/comenzi", (ComandaNoua c) => Results.Created($"/comenzi/1", c));
record ComandaNoua(string Client, int Cantitate);
1. corp {"client":"Ana","cantitate":2}, Content-Type: text/plain
2. corp {"client":"Ana","cantitate":"doi"}, Content-Type: application/json
3. fără corp, Content-Type: application/json

Răspuns scurt: 1: 415 Unsupported Media Type, pentru că un parametru din corp acceptă doar JSON. 2: 400, JSON-ul nu poate fi convertit ("doi" nu e int). 3: 400, corpul obligatoriu lipsește. În Development, corpul răspunsurilor 400 conține mesajul BadHttpRequestException.

Parametrul ComandaNoua este inferat din corp, iar Minimal APIs îl citește cu System.Text.Json numai dacă cererea are Content-Type: application/json (sau un tip +json).

1. Cu text/plain, framework-ul nici nu încearcă să citească corpul: răspunde 415. Clientul a trimis date bune cu antetul greșit, o situație frecventă când testezi cu curl -d fără -H "Content-Type: application/json". 2. JSON-ul e valid sintactic, dar "doi" nu se poate deserializa în int. Se aruncă intern BadHttpRequestException și răspunsul este 400; în Development corpul este de tipul Failed to read parameter "ComandaNoua c" from the request body as JSON. La JSON invalid sintactic (o acoladă lipsă) rezultatul este tot 400. 3. Fără corp, parametrul non-nullable este obligatoriu: 400 cu Implicit body inferred for parameter "ComandaNoua c" but no body was provided. Dacă parametrul ar fi ComandaNoua? c, handler-ul ar rula cu null.

În Production, aceste 400 au implicit corpul gol. Cu builder.Services.AddProblemDetails(), răspunsurile de eroare devin application/problem+json, mai ușor de interpretat de client.

Pentru depanare, logurile framework-ului spun exact ce s-a întâmplat (categoria Microsoft.AspNetCore.Http.Result / RequestDelegateFactory, la nivel Debug). Opțiunea RouteHandlerOptions.ThrowOnBadRequest = true transformă aceste cazuri în excepții vizibile, util doar local.

Ce urmărește intervievatorul: Verifică dacă poți diagnostica rapid un client care se plânge de 400 sau 415. Candidații slabi caută bug-ul în handler, care nici nu a rulat.

Eroarea, în practică:Failed to read parameter from the request body as JSRequired parameter was not provided from body

23 Junior

Ce primește clientul (status, Content-Type, corp) pentru fiecare endpoint?

C#
app.MapGet("/a", () => "salut");
app.MapGet("/b", () => new { Nume = "Mouse", Pret = 99.5m });
app.MapGet("/c", () => Results.Ok("salut"));
app.MapGet("/d", () => Results.Text("<b>salut</b>", "text/html"));
app.MapGet("/e", () => Results.NoContent());

Răspuns scurt: /a: 200, text/plain, salut. /b: 200, application/json, {"nume":"Mouse","pret":99.5}. /c: 200, JSON, "salut" cu ghilimele. /d: 200, text/html. /e: 204 fără corp.

Regulile de scriere a rezultatului în Minimal APIs:

  • un string întors direct este scris ca text simplu, text/plain; charset=utf-8;
  • orice alt obiect este serializat JSON cu System.Text.Json, cu proprietăți în camelCase (de aceea Nume devine nume), application/json; charset=utf-8;
  • un IResult (Results.*, TypedResults.*) își controlează singur statusul, antetele și corpul;
  • Task<T> și ValueTask<T> sunt așteptate, apoi se aplică aceleași reguli.

Diferența surprinzătoare este între /a și /c. Results.Ok("salut") serializează valoarea ca JSON, deci corpul este "salut", cu ghilimele, și Content-Type JSON. Un client care face JSON.parse pe /a primește eroare, iar unul care afișează textul de la /c vede ghilimele în plus.

Results.Text(conținut, contentType) (sau Results.Content) scrie exact textul, cu tipul ales. Results.NoContent() dă 204 și niciun corp, potrivit după un PUT sau DELETE reușit.

Pentru un API consistent, alege o singură convenție: răspunsurile de date mereu JSON (obiecte, nu string-uri goale), erorile mereu ProblemDetails. Un șir întors direct e potrivit doar pentru endpoint-uri tehnice, de exemplu un health check simplu.

Serializarea se configurează global cu builder.Services.ConfigureHttpJsonOptions(o => ...): politica de nume, convertoarele pentru enum-uri ca text, ignorarea valorilor null.

Ce urmărește intervievatorul: Verifică dacă știi exact ce pleacă pe fir, nu doar că „se întoarce JSON”. Diferența "salut" față de salut creează des bug-uri la integrarea cu frontend-ul.

Eroarea, în practică:CS0029: 'string' to 'IResult'

24 Junior

Ce răspunde fiecare cerere, în proiectul creat cu dotnet new web (cu <Nullable>enable</Nullable>)?

C#
app.MapGet("/cauta", (string termen, string? categorie, int pagina = 1) =>
    $"{termen} | {categorie ?? "toate"} | {pagina}");
GET /cauta?termen=mouse
GET /cauta?termen=mouse&categorie=gaming&pagina=2
GET /cauta?categorie=gaming
GET /cauta?termen=mouse&pagina=doi

Răspuns scurt: Primele două răspund 200: mouse | toate | 1 și mouse | gaming | 2. A treia dă 400, pentru că string termen non-nullable este obligatoriu. A patra dă tot 400, doi nu se poate converti în int.

Minimal APIs folosește adnotările de nulabilitate ale C# ca să decidă ce e obligatoriu:

  • string termen: tip referință non-nullable, deci obligatoriu. Lipsa lui dă 400, cu mesajul (în Development) Required parameter "string termen" was not provided from query string.;
  • string? categorie: opțional, devine null când lipsește;
  • int pagina = 1: opțional datorită valorii implicite; int pagina fără valoare ar fi obligatoriu, iar int? pagina ar fi opțional, cu null.

A patra cerere arată diferența dintre „lipsește” și „invalid”: pagina=doi există, dar int.TryParse eșuează, deci rezultatul este 400 cu Failed to bind parameter "int pagina" from "doi"., chiar dacă parametrul are valoare implicită.

Același cod într-un proiect cu nulabilitatea dezactivată se comportă diferit: string termen devine opțional și primești null, deci un NullReferenceException mai târziu. De aceea comportamentul depinde de setarea <Nullable> din csproj, un detaliu care derutează când muți cod între proiecte.

Recomandarea practică: declară explicit intenția. Parametrii obligatorii rămân non-nullable, filtrele opționale primesc ? sau valori implicite, iar regulile suplimentare (lungime minimă, interval) le verifici în handler sau într-un filtru, cu un mesaj clar pentru client.

Ce urmărește intervievatorul: Verifică legătura dintre nullable reference types și binding, un detaliu specific ASP.NET Core modern. Greșeala tipică este să crezi că string e mereu opțional.

Eroarea, în practică:Required parameter was not provided from routeRequired parameter not provided from query string

25 Junior

Scrie un endpoint care primește o listă de etichete din query string (?tag=mouse&tag=wireless) și id-ul clientului din antetul X-Client-Id.

Răspuns scurt: Declari un tablou de tip simplu, string[] tag, care se leagă din query string când parametrul se repetă, și [FromHeader(Name = "X-Client-Id")] string clientId pentru antet. Pentru un nume de query diferit de cel C#, folosești [FromQuery(Name = "...")].

C#
app.MapGet("/produse", (
    [FromQuery(Name = "tag")] string[] etichete,
    [FromHeader(Name = "X-Client-Id")] string clientId,
    [FromQuery(Name = "pe-pagina")] int pePagina = 20) =>
{
    return new { clientId, etichete, pePagina };
});

Pentru GET /produse?tag=mouse&tag=wireless cu antetul X-Client-Id: 42, răspunsul este {"clientId":"42","etichete":["mouse","wireless"],"pePagina":20}.

Detalii:

  • un tablou de tipuri simple (string[], int[], StringValues) primește toate valorile cu același nume. Dacă parametrul lipsește, tabloul este gol, nu null; dacă o valoare nu se poate converti (?id=1&id=x pentru int[] id), rezultatul este 400;
  • forma ?tag=mouse,wireless nu este împărțită automat: primești un singur element, "mouse,wireless". Dacă vrei acest format, îl împarți singur sau scrii un tip cu TryParse;
  • [FromHeader] este obligatoriu pentru antete: fără atribut, parametrul ar fi căutat în query. Un antet lipsă pentru un string non-nullable dă 400 cu Required parameter "string clientId" was not provided from header.;
  • Name permite nume care nu sunt identificatori C# valizi (pe-pagina, X-Client-Id).

Atributele sunt în Microsoft.AspNetCore.Mvc ([FromQuery], [FromHeader], [FromBody]), comune pentru controllere și Minimal APIs. Pentru mulți parametri de felul acesta, [AsParameters] îi grupează într-un singur tip.

Ce urmărește intervievatorul: Verifică binding-ul din surse mai puțin obișnuite. Mulți candidați presupun greșit că ?tag=a,b devine automat o listă.

Eroarea, în practică:Required parameter was not provided from header

26 Mid

Care este diferența dintre Results.Ok(...) și TypedResults.Ok(...)? De ce ai scrie tipul de retur Results<Ok<Produs>, NotFound>?

Răspuns scurt: Results.Ok întoarce un IResult generic, iar TypedResults.Ok întoarce tipul concret Ok<Produs>. Cu Results<Ok<Produs>, NotFound>, compilatorul verifică ce răspunsuri poate da handler-ul, OpenAPI le documentează automat, iar testele unitare pot verifica tipul rezultatului.

Ambele produc același răspuns HTTP. Diferența este în tipul static:

C#
// IResult: nimeni nu știe ce poate întoarce, nici compilatorul, nici OpenAPI
app.MapGet("/v1/produse/{id:int}", (int id, ICatalog c) =>
    c.Gaseste(id) is { } p ? Results.Ok(p) : Results.NotFound());

// tipuri concrete
app.MapGet("/v2/produse/{id:int}", Results<Ok<Produs>, NotFound> (int id, ICatalog c) =>
    c.Gaseste(id) is { } p ? TypedResults.Ok(p) : TypedResults.NotFound());

Results<T1, T2> (până la șase tipuri) este o uniune: are conversii implicite din fiecare tip, deci poți întoarce oricare dintre ele, dar nu altceva. Dacă adaugi return TypedResults.BadRequest(); fără să extinzi tipul, codul nu compilează. Pentru expresia ternară cu două tipuri diferite trebuie să declari tipul de retur al lambda-ului (ca mai sus), altfel compilatorul nu găsește un tip comun.

Avantaje:

  • OpenAPI: tipurile implementează IEndpointMetadataProvider, deci documentul descrie automat 200 cu schema Produs și 404, fără .Produces<Produs>(200);
  • teste unitare pe handler-ul scris ca metodă: var r = await Handlere.DupaId(9, catalog); Assert.IsType<NotFound>(r.Result); sau var ok = Assert.IsType<Ok<Produs>>(r.Result); Assert.Equal("Mouse", ok.Value!.Nume);;
  • refactorizare sigură: un răspuns nou trebuie declarat explicit.

Results rămâne util pentru cod scurt, unde tipul exact nu contează.

Ce urmărește intervievatorul: Verifică dacă folosești Minimal APIs la nivel de producție, cu documentare și teste. Un candidat bun explică de ce lambda-ul are nevoie de tipul de retur explicit.

Eroarea, în practică:CS0246: 'Ok<>' could not be found (TypedResults)CS1662: lambda cu tipuri de retur diferite

27 Mid

Un endpoint de listare are șapte parametri de filtrare și paginare. Cum îl simplifici cu [AsParameters]? Ce reguli trebuie să respecte tipul?

Răspuns scurt: Muți parametrii într-un record sau într-o clasă și scrii ([AsParameters] FiltruProduse f). Fiecare proprietate sau parametru de constructor se leagă ca și cum ar fi fost parametru separat, cu aceleași reguli de inferență și cu atributele [FromQuery], [FromHeader], [FromServices] puse pe membri.

C#
app.MapGet("/produse", ([AsParameters] FiltruProduse f) =>
{
    var q = f.Catalog.Toate().AsEnumerable();
    if (f.Categorie is not null) q = q.Where(p => p.Categorie == f.Categorie);
    if (f.PretMax is not null) q = q.Where(p => p.Pret <= f.PretMax);
    return q.Skip((f.Pagina - 1) * f.PePagina).Take(f.PePagina);
});

record FiltruProduse(
    string? Categorie,
    decimal? PretMax,
    [FromQuery(Name = "pe-pagina")] int PePagina = 20,
    int Pagina = 1,
    [FromHeader(Name = "X-Limba")] string? Limba = null,
    ICatalog Catalog = null!);

GET /produse?categorie=mouse&pagina=2&pe-pagina=10 completează tipul, iar Catalog vine din DI pentru că ICatalog este înregistrat.

Reguli:

  • pentru un record sau o clasă cu un singur constructor public cu parametri, se leagă parametrii constructorului; pentru o clasă cu constructor fără parametri, proprietățile publice cu set/init;
  • tipul nu poate fi abstract și nu poate conține la rândul lui [AsParameters];
  • poate avea cel mult un membru din corp, ca orice endpoint;
  • valorile implicite ale parametrilor de record fac membrii opționali, ca la parametrii obișnuiți.

Câștigul real: același tip de filtru se refolosește la mai multe endpoint-uri, se validează într-un singur loc (un endpoint filter care caută FiltruProduse) și se testează separat. În OpenAPI, membrii apar ca parametri individuali, deci clienții nu observă diferența.

Ce urmărește intervievatorul: Verifică dacă știi instrumentele de organizare din .NET 7+, nu doar varianta cu mulți parametri. Greșeala frecventă este folosirea [FromQuery] pe tot obiectul, care nu funcționează în Minimal APIs ca în controllere.

28 Mid

Cum întorci erori în format ProblemDetails dintr-un Minimal API? Ce face builder.Services.AddProblemDetails() și ce primește clientul?

Răspuns scurt: Pentru erori explicite folosești Results.Problem(...) sau Results.ValidationProblem(erori), cu application/problem+json (RFC 9457). AddProblemDetails() face ca și răspunsurile generate de framework (excepții, 404/400 fără corp, cu UseExceptionHandler și UseStatusCodePages) să aibă același format.

ProblemDetails este formatul standard pentru erori HTTP: type, title, status, detail, instance și extensii proprii. Din handler îl produci direct:

C#
app.MapPost("/comenzi", (ComandaNoua c, IStoc stoc) =>
{
    if (c.Cantitate <= 0)
        return Results.ValidationProblem(new Dictionary<string, string[]>
        {
            ["cantitate"] = ["Cantitatea trebuie să fie pozitivă."]
        });

    if (!stoc.Disponibil(c.ProdusId, c.Cantitate))
        return Results.Problem(
            title: "Stoc insuficient",
            detail: $"Produsul {c.ProdusId} nu mai are {c.Cantitate} bucăți.",
            statusCode: StatusCodes.Status409Conflict,
            extensions: new Dictionary<string, object?> { ["produsId"] = c.ProdusId });

    return Results.Created($"/comenzi/1", c);
});

Clientul primește, pentru al doilea caz, 409 cu {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.10","title":"Stoc insuficient","status":409,"detail":"...","produsId":5}. ValidationProblem dă 400 cu titlul One or more validation errors occurred. și dicționarul errors.

Fără configurare, framework-ul trimite însă multe erori cu corp gol: un 404 din rutare, un 400 de binding, o excepție neprinsă în Production. Cu

C#
builder.Services.AddProblemDetails(o => o.CustomizeProblemDetails = ctx =>
    ctx.ProblemDetails.Extensions["traceId"] = ctx.HttpContext.TraceIdentifier);
app.UseExceptionHandler();
app.UseStatusCodePages();

toate devin ProblemDetails, iar CustomizeProblemDetails adaugă câmpuri comune, ca traceId, util la corelarea cu logurile. Formatul unitar permite frontend-ului un singur cod de tratare a erorilor.

Ce urmărește intervievatorul: Verifică dacă știi standardul și diferența dintre erorile tale și cele generate de framework. Tratarea globală a excepțiilor este alt subiect; aici contează formatul răspunsurilor din Minimal APIs.

29 Senior

Vrei ca GET /magazine/aproape?locatie=44.43,26.10 să primească direct un parametru Coordonate locatie. Cum faci tipul tău legabil din query, și când ai folosi BindAsync în loc de TryParse?

Răspuns scurt: Adaugi tipului o metodă statică TryParse(string?, IFormatProvider?, out Coordonate), iar Minimal APIs îl tratează ca pe un tip simplu din rută, query sau antet. BindAsync(HttpContext, ParameterInfo) e pentru legări care au nevoie de toată cererea.

C#
public readonly record struct Coordonate(double Lat, double Lon)
{
    public static bool TryParse(string? text, IFormatProvider? provider, out Coordonate rezultat)
    {
        rezultat = default;
        var parti = text?.Split(',');
        if (parti is not { Length: 2 }) return false;
        if (!double.TryParse(parti[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var lat) ||
            !double.TryParse(parti[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var lon))
            return false;
        if (lat is < -90 or > 90 || lon is < -180 or > 180) return false;
        rezultat = new Coordonate(lat, lon);
        return true;
    }
}

app.MapGet("/magazine/aproape", (Coordonate locatie) => $"{locatie.Lat} {locatie.Lon}");

Dacă TryParse întoarce false, răspunsul este 400 (Failed to bind parameter "Coordonate locatie" from "abc".), iar dacă parametrul lipsește și nu e nullable, tot 400. CultureInfo.InvariantCulture e esențial: pe un server cu cultura ro-RO, separatorul zecimal ar fi virgula și parsarea ar eșua.

BindAsync are acces la tot HttpContext:

C#
public record Paginare(int Pagina, int PePagina)
{
    public static ValueTask<Paginare?> BindAsync(HttpContext ctx, ParameterInfo p)
    {
        int.TryParse(ctx.Request.Query["pagina"], out var pag);
        int.TryParse(ctx.Request.Query["pe-pagina"], out var pe);
        return ValueTask.FromResult<Paginare?>(new(Math.Max(pag, 1), Math.Clamp(pe, 1, 100)));
    }
}

Din .NET 7 există și interfața IBindableFromHttpContext<T>, cu aceeași semnătură ca membru static abstract. Regula: TryParse pentru valori care încap într-un șir, BindAsync pentru legări compuse sau citiri asincrone. Pentru simple grupări de parametri, [AsParameters] e mai clar.

Ce urmărește intervievatorul: Verifică extensibilitatea binding-ului, specifică Minimal APIs, și atenția la cultură. Puțini candidați știu că TryParse cu semnătura corectă e suficient.

Eroarea, în practică:Failed to bind parameter "int x" from "..."Failed to bind parameter (DateOnly/DateTime)

30 Senior

Ai configurat enum-urile ca text și numele proprietăților în snake_case, dar endpoint-urile Minimal API întorc tot numere și camelCase. Unde e bug-ul?

C#
builder.Services.AddControllers().AddJsonOptions(o =>
{
    o.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
    o.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower;
});
...
app.MapGet("/comenzi/{id:int}", (int id) => new Comanda(id, Stare.Livrata));

Răspuns scurt: AddJsonOptions configurează doar serializarea MVC (Microsoft.AspNetCore.Mvc.JsonOptions). Minimal APIs folosesc alt obiect, Microsoft.AspNetCore.Http.Json.JsonOptions, configurat cu builder.Services.ConfigureHttpJsonOptions(...). Într-o aplicație cu ambele, setezi ambele, ideal din aceeași metodă.

ASP.NET Core are două clase numite JsonOptions, în namespace-uri diferite:

  • Microsoft.AspNetCore.Mvc.JsonOptions: folosită de controllere (input și output formatters), configurată cu AddControllers().AddJsonOptions(...);
  • Microsoft.AspNetCore.Http.Json.JsonOptions: folosită de Minimal APIs, de Results.Json, ReadFromJsonAsync, WriteAsJsonAsync și de ProblemDetails, configurată cu ConfigureHttpJsonOptions.

Endpoint-ul din exemplu ignoră complet setările, deci răspunde {"id":5,"stare":2} în loc de {"id":5,"stare":"Livrata"}.

Soluția robustă este o singură sursă de adevăr:

C#
static void ConfigJson(JsonSerializerOptions o)
{
    o.Converters.Add(new JsonStringEnumConverter());
    o.PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower;
}

builder.Services.ConfigureHttpJsonOptions(o => ConfigJson(o.SerializerOptions));
builder.Services.AddControllers().AddJsonOptions(o => ConfigJson(o.JsonSerializerOptions));

O variantă a aceleiași capcane: builder.Services.Configure<JsonOptions>(...) cu using greșit compilează fără avertisment, dar configurează celălalt sistem. În code review merită verificat namespace-ul.

De reținut și efectele asupra clienților: schimbarea politicii de nume sau trecerea enum-urilor la text este o schimbare incompatibilă a contractului API. Clienții existenți care citesc stare == 2 se strică. Asemenea decizii se iau la începutul proiectului sau se introduc într-o versiune nouă a API-ului. Un test de integrare care compară JSON-ul unui răspuns cu un exemplu salvat (snapshot) prinde schimbările accidentale.

Ce urmărește intervievatorul: Verifică experiența cu aplicații care amestecă controllere și Minimal APIs, foarte frecvente după migrări. Seniorii pomenesc și impactul asupra contractului cu clienții.

Dependency injection și durate de viață

31 Junior

Aplicația nu pornește și afișează „Body was inferred but the method does not allow inferred body parameters”. Care este cauza în codul de mai jos?

C#
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/rapoarte/vanzari", (IServiciuRapoarte rapoarte) => rapoarte.Vanzari());
app.Run();

Răspuns scurt: IServiciuRapoarte nu este înregistrat în DI, deci Minimal APIs nu îl recunoaște ca serviciu și îl consideră corpul cererii, care nu e permis la GET. Repari cu builder.Services.AddScoped<IServiciuRapoarte, ServiciuRapoarte>(); înainte de Build().

Inferența surselor de parametri verifică, între altele, dacă tipul este înregistrat în containerul de servicii (prin IServiceProviderIsService). Un tip complex care nu e serviciu, nu e special și nu are TryParse/BindAsync este presupus a fi corpul JSON. La GET, DELETE sau HEAD, un corp inferat nu e permis, iar aplicația se oprește la construirea endpoint-urilor cu:

System.InvalidOperationException: Body was inferred but the method does not allow inferred body parameters.
Below is the list of parameters that we found:
Parameter           | Source
---------------------------------------------------------------------------------
rapoarte            | Body (Inferred)

Did you mean to register the "Body (Inferred)" parameter(s) as a Service or apply the [FromServices] or [FromBody] attribute?

Mesajul îți dă chiar soluția: înregistrezi serviciul. Cu [FromServices] IServiciuRapoarte rapoarte aplicația ar porni, dar fiecare cerere s-ar termina cu 500 și No service for type 'IServiciuRapoarte' has been registered., deci atributul doar mută eroarea mai târziu.

Pe un MapPost, aceeași greșeală e mai perfidă: corpul inferat este permis, aplicația pornește, iar la cerere framework-ul încearcă să deserializeze JSON într-o interfață și eșuează. Simptomul pare o problemă de JSON, deși cauza este o înregistrare lipsă.

Pentru a prinde devreme asemenea omisiuni: un test de integrare care pornește aplicația cu WebApplicationFactory<Program> și cere fiecare endpoint măcar o dată, plus [FromServices] explicit acolo unde vrei ca intenția să fie clară la citirea codului.

Ce urmărește intervievatorul: Verifică dacă poți citi un mesaj de eroare lung și îl poți lega de inferența din Minimal APIs. Candidații slabi adaugă [FromBody] și transformă problema în alta.

Eroarea, în practică:Body was inferred but the method does not allow ...

32 Junior

Care este diferența dintre aceste înregistrări și când o folosești pe fiecare?

C#
builder.Services.AddScoped<IRepoComenzi, RepoComenziSql>();
builder.Services.AddScoped<ServiciuFacturi>();
builder.Services.AddSingleton(new SetariTva(0.19m));
builder.Services.AddSingleton<IOra>(sp => new OraSistem(TimeZoneInfo.Utc));

Răspuns scurt: Prima leagă o interfață de implementare, a doua înregistrează o clasă concretă, a treia o instanță creată de tine, iar a patra o fabrică. Interfața ajută la testare; instanța și fabrica servesc când constructorul cere valori pe care containerul nu le știe.

  • AddScoped<IRepoComenzi, RepoComenziSql>(): cine cere IRepoComenzi primește RepoComenziSql, creat de container cu dependențele din constructor. Este forma potrivită pentru tot ce vrei să înlocuiești în teste sau între medii (un repository fals, un serviciu de email simulat).
  • AddScoped<ServiciuFacturi>(): tipul concret este și cheia. Simplu și suficient pentru clase interne fără variante, dar consumatorii depind de implementare.
  • AddSingleton(new SetariTva(0.19m)): tu creezi obiectul, containerul doar îl ține. Instanța există înainte de Build(), iar containerul nu o eliberează (Dispose) la oprire, pentru că nu a creat-o el.
  • AddSingleton<IOra>(sp => new OraSistem(TimeZoneInfo.Utc)): o fabrică. Se apelează o dată pentru singleton, o dată per scope pentru scoped, la fiecare cerere pentru transient. Prin sp poți cere alte servicii (sp.GetRequiredService<IConfiguration>()), util când un parametru vine din configurare.

Cu fabrica pierzi însă o parte din validări: containerul nu vede ce servicii ceri înăuntru, deci ValidateOnBuild nu poate verifica dependențe lipsă sau captive. Folosește-o doar când constructorul chiar nu poate fi rezolvat automat.

Pentru valori din configurare, Options pattern (IOptions<SetariTva>) e de obicei mai potrivit decât o instanță construită de mână, pentru că se leagă de appsettings.json și poate fi validat la pornire.

Ce urmărește intervievatorul: Verifică dacă știi formele de înregistrare și consecințele lor, nu doar AddScoped. Puțini candidați știu că instanța dată de tine nu este eliberată de container.

Eroarea, în practică:Cannot instantiate implementation type

33 Junior

Ce afișează endpoint-ul?

C#
builder.Services.AddScoped<INotificare, NotificareEmail>();
builder.Services.AddScoped<INotificare, NotificareSms>();
...
app.MapGet("/test", (INotificare una, IEnumerable<INotificare> toate) =>
    $"{una.GetType().Name} | {string.Join(", ", toate.Select(n => n.GetType().Name))}");

Răspuns scurt: Afișează NotificareSms | NotificareEmail, NotificareSms. Când ceri un singur serviciu, câștigă ultima înregistrare; când ceri IEnumerable<INotificare>, primești toate implementările, în ordinea înregistrării.

Containerul din Microsoft.Extensions.DependencyInjection nu aruncă eroare la înregistrări multiple pentru același tip. Le păstrează pe toate, în ordine:

  • rezolvarea unui singur INotificare folosește ultima înregistrare, de aceea apare NotificareSms;
  • IEnumerable<INotificare> (și GetServices<INotificare>()) creează câte o instanță din fiecare, în ordinea în care au fost adăugate.

Comportamentul are două consecințe practice.

Prima, utilă: poți implementa un model de tip „plugin” sau „chain”. De exemplu, toate regulile de validare a unei comenzi sunt înregistrate ca IRegulaComanda, iar serviciul le primește pe toate:

C#
class ValidatorComenzi(IEnumerable<IRegulaComanda> reguli)
{
    public List<string> Valideaza(Comanda c) =>
        reguli.Select(r => r.Verifica(c)).OfType<string>().ToList();
}

Adăugarea unei reguli noi înseamnă o singură linie în înregistrare, fără să modifici validatorul.

A doua, periculoasă: o bibliotecă sau un modul care înregistrează din nou un serviciu îl înlocuiește în tăcere pentru toți consumatorii obișnuiți. De aceea bibliotecile folosesc TryAdd..., care nu adaugă dacă există deja o înregistrare.

Dacă vrei să alegi o implementare anume după un criteriu (metoda de plată „card” sau „transfer”), ai două variante: IEnumerable plus o proprietate de identificare pe fiecare implementare, sau keyed services din .NET 8.

Ce urmărește intervievatorul: Verifică dacă știi semantica înregistrărilor multiple, sursă de bug-uri greu de găsit. Răspunsul greșit tipic este că a doua înregistrare aruncă o excepție.

34 Junior

Ce fac TryAddScoped, TryAddEnumerable, Replace și RemoveAll? Unde le-ai folosi?

Răspuns scurt: TryAddScoped adaugă doar dacă tipul nu e înregistrat, TryAddEnumerable doar dacă perechea serviciu–implementare lipsește, Replace înlocuiește prima înregistrare, iar RemoveAll le șterge pe toate. Le folosești în biblioteci reutilizabile și în teste.

Metodele sunt în Microsoft.Extensions.DependencyInjection.Extensions.

Într-o bibliotecă, de exemplu un modul de facturare publicat ca pachet NuGet, vrei să oferi o implementare implicită, dar să lași aplicația să o suprascrie, indiferent de ordinea apelurilor:

C#
public static IServiceCollection AddFacturare(this IServiceCollection services)
{
    services.TryAddSingleton<IOra, OraSistem>();            // doar dacă aplicația nu are deja un IOra
    services.TryAddScoped<IServiciuFacturi, ServiciuFacturi>();
    services.TryAddEnumerable(ServiceDescriptor.Scoped<IRegulaFactura, RegulaTva>());
    return services;
}

Dacă aplicația a înregistrat deja IOra cu un ceas propriu, TryAddSingleton nu îl înlocuiește. TryAddEnumerable previne dublurile când AddFacturare() este apelat de două ori: fără el, regula TVA ar rula de două ori.

În teste de integrare, înlocuiești servicii reale cu dubluri:

C#
services.RemoveAll<IServiciuEmail>();
services.AddSingleton<IServiciuEmail, EmailFals>();
// sau
services.Replace(ServiceDescriptor.Singleton<IOra>(new OraFixa(new DateTime(2026, 1, 15))));

Replace schimbă doar prima înregistrare a tipului; dacă există mai multe (de exemplu implementări multiple), restul rămân, iar RemoveAll urmat de Add este mai sigur.

Diferența față de Add simplu: acesta adaugă mereu, iar la rezolvare câștigă ultima înregistrare, deci rezultatul depinde de ordinea apelurilor din Program.cs. Cu TryAdd, comportamentul nu mai depinde de ordine.

Ce urmărește intervievatorul: Verifică dacă ai scris cod reutilizabil sau teste de integrare cu servicii înlocuite. Un semnal bun este explicarea diferenței dintre TryAdd și TryAddEnumerable.

35 Junior

Compară cele trei moduri de a obține un serviciu. Care este problema cu al treilea?

C#
// 1
class ServiciuComenzi(IRepoComenzi repo) { ... }
// 2
app.MapPost("/comenzi", ([FromServices] IRepoComenzi repo, ComandaNoua c) => ...);
// 3
class ServiciuComenzi(IServiceProvider sp)
{
    public void Plaseaza(Comanda c) => sp.GetRequiredService<IRepoComenzi>().Salveaza(c);
}

Răspuns scurt: 1 este injecția prin constructor, forma recomandată. 2 este injecția în handler, la fel de bună în Minimal APIs. 3 este service locator: dependențele sunt ascunse, nu apar în constructor, iar o înregistrare lipsă se vede abia când metoda rulează.

Injecția prin constructor face dependențele explicite: cine citește clasa vede ce îi trebuie, testele o construiesc cu dubluri (new ServiciuComenzi(repoFals)), iar containerul verifică la construire că poate rezolva tot. Cu C# 12, constructorul primar scurtează codul; reține că parametrul capturat nu este readonly, deci poate fi reatribuit din greșeală. Dacă asta te deranjează, îl atribui unui câmp private readonly.

Injecția în handler este echivalentul pentru Minimal APIs: serviciul este rezolvat din scope-ul cererii. [FromServices] e opțional când tipul e înregistrat, dar face intenția clară. În controllere, poți injecta în acțiune la fel, când un serviciu e folosit de o singură acțiune.

Service locator (IServiceProvider în constructor, HttpContext.RequestServices.GetService<T>()) are mai multe probleme:

  • dependențele reale nu se văd din semnătură, deci clasa minte despre ce are nevoie;
  • testele trebuie să construiască un container întreg;
  • ValidateOnBuild nu poate verifica nimic, iar o înregistrare lipsă dă InvalidOperationException în producție, pe ramura de cod care o folosește;
  • dacă sp este providerul rădăcină (clasa e singleton), un serviciu scoped cerut astfel trăiește cât aplicația.

Există cazuri legitime: fabrici care aleg implementarea la rulare, middleware-uri convenționale, servicii de fundal care își creează propriul scope. Chiar și acolo, preferă IServiceScopeFactory sau o fabrică dedicată (Func<T>, keyed services) în locul lui IServiceProvider brut.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce injecția prin constructor e regula, nu doar că există. Candidații care folosesc RequestServices peste tot au de obicei probleme cu testarea.

Eroarea, în practică:No service for type has been registered

36 Mid

Ce sunt keyed services (.NET 8)? Scrie un exemplu cu două implementări ale lui IProcesatorPlata alese după metodă.

Răspuns scurt: Keyed services înregistrează mai multe implementări ale aceleiași interfețe, fiecare cu o cheie: AddKeyedScoped<IProcesatorPlata, PlataCard>("card"). Le ceri cu [FromKeyedServices("card")] sau, când cheia vine la rulare, cu GetRequiredKeyedService<T>(cheie).

C#
builder.Services.AddKeyedScoped<IProcesatorPlata, PlataCard>("card");
builder.Services.AddKeyedScoped<IProcesatorPlata, PlataTransfer>("transfer");
builder.Services.AddScoped<ServiciuCheckout>();

// cheie fixă, cunoscută la compilare
app.MapPost("/plati/card", ([FromKeyedServices("card")] IProcesatorPlata p, Plata date) =>
    p.Proceseaza(date));

// cheie aleasă la rulare
class ServiciuCheckout(IServiceProvider sp)
{
    public Rezultat Plateste(string metoda, Plata date)
    {
        var procesator = sp.GetKeyedService<IProcesatorPlata>(metoda)
            ?? throw new ArgumentException($"Metodă de plată necunoscută: {metoda}");
        return procesator.Proceseaza(date);
    }
}

[FromKeyedServices] funcționează și în constructori (class Raport([FromKeyedServices("pdf")] IExport export)), iar cheia poate fi orice obiect, inclusiv un enum, ceea ce evită șirurile scrise greșit. GetRequiredKeyedService aruncă dacă nu există implementare pentru cheie, GetKeyedService întoarce null.

Alternativele de dinainte de .NET 8, încă valabile:

  • IEnumerable<IProcesatorPlata> cu o proprietate Metoda pe fiecare implementare și o căutare după ea; are avantajul că lista de metode disponibile se obține ușor, de exemplu pentru un endpoint care le afișează;
  • o fabrică proprie IFabricaPlati cu un switch.

Keyed services sunt potrivite când cheile sunt fixe și cunoscute (canale de notificare, formate de export, clienți pentru furnizori diferiți). Când logica de alegere depinde de reguli de business, o fabrică explicită este mai ușor de citit și de testat. Rezolvarea cu cheie la rulare rămâne o formă de service locator, deci păstreaz-o într-un singur loc.

Ce urmărește intervievatorul: Verifică dacă ești la curent cu .NET 8 și dacă știi alternativele. Un candidat bun discută și când keyed services complică inutil codul.

37 Mid

Ai IRepository<T> și o implementare generică RepositoryEf<T>. Cum le înregistrezi o singură dată pentru toate entitățile? Cum ai adăuga un decorator de logging peste ele?

Răspuns scurt: Înregistrezi tipurile generice deschise: AddScoped(typeof(IRepository<>), typeof(RepositoryEf<>)); containerul le închide la cerere. Decoratorii nu sunt suportați direct: îi faci cu o fabrică pentru tipuri concrete sau cu biblioteca Scrutor.

C#
builder.Services.AddScoped(typeof(IRepository<>), typeof(RepositoryEf<>));

public interface IRepository<T> where T : class
{
    Task<T?> GasesteAsync(int id);
    Task AdaugaAsync(T entitate);
}

public class RepositoryEf<T>(AppDb db) : IRepository<T> where T : class
{
    public async Task<T?> GasesteAsync(int id) => await db.Set<T>().FindAsync(id);
    public async Task AdaugaAsync(T e) { db.Set<T>().Add(e); await db.SaveChangesAsync(); }
}

Un handler care cere IRepository<Produs> primește RepositoryEf<Produs>, iar unul care cere IRepository<Client> primește RepositoryEf<Client>, fără înregistrări separate. Așa este înregistrat și ILogger<T> în framework. Constrângerile generice (where T : class) sunt respectate: dacă un tip nu le îndeplinește, containerul nu poate crea serviciul.

O înregistrare închisă are prioritate față de cea deschisă: AddScoped<IRepository<Comanda>, RepositoryComenzi>() folosește implementarea specială doar pentru comenzi.

Pentru un decorator pe un tip concret:

C#
builder.Services.AddScoped<RepositoryEf<Comanda>>();
builder.Services.AddScoped<IRepository<Comanda>>(sp =>
    new RepositoryCuLog<Comanda>(sp.GetRequiredService<RepositoryEf<Comanda>>(),
                                 sp.GetRequiredService<ILogger<RepositoryCuLog<Comanda>>>()));

Pentru decoratori pe tipuri generice deschise, containerul implicit nu are API, iar biblioteca Scrutor oferă services.Decorate(typeof(IRepository<>), typeof(RepositoryCuLog<>)).

O observație de design: un repository generic peste EF Core adaugă adesea puțin față de DbSet<T>; tehnica tipurilor generice deschise rămâne însă utilă pentru handler-e de comenzi, validatori sau politici de cache.

Ce urmărește intervievatorul: Verifică stăpânirea containerului dincolo de înregistrările simple. Un candidat bun știe că decoratorii nu sunt suportați direct și ce opțiuni are.

38 Mid

Un BackgroundService trebuie să proceseze la fiecare minut comenzile neplătite folosind AppDb (un DbContext). Scrie serviciul corect și explică de ce nu poți injecta AppDb direct în constructor.

Răspuns scurt: Serviciile găzduite sunt singleton, iar AppDb este scoped: injectat direct, ar trăi cât aplicația, iar în Development pornirea pică. Injectezi IServiceScopeFactory și creezi un scope nou la fiecare iterație, din care ceri contextul.

AddHostedService<T>() înregistrează serviciul ca singleton. Dacă i-ai cere AppDb în constructor, validarea scope-urilor din Development ar opri aplicația cu Cannot consume scoped service 'AppDb' from singleton 'Microsoft.Extensions.Hosting.IHostedService'. Fără validare, ar fi și mai rău: un singur DbContext pentru toată viața procesului, care acumulează entități urmărite și nu este sigur pentru folosire concurentă.

C#
builder.Services.AddDbContext<AppDb>(o => o.UseSqlServer(cs));
builder.Services.AddHostedService<ProcesatorComenzi>();

public class ProcesatorComenzi(IServiceScopeFactory scopeFactory, ILogger<ProcesatorComenzi> log)
    : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromMinutes(1));
        while (await timer.WaitForNextTickAsync(stoppingToken))
        {
            try
            {
                await using var scope = scopeFactory.CreateAsyncScope();
                var db = scope.ServiceProvider.GetRequiredService<AppDb>();
                var neplatite = await db.Comenzi
                    .Where(c => c.Stare == Stare.Neplatita)
                    .ToListAsync(stoppingToken);
                foreach (var c in neplatite) c.Stare = Stare.Anulata;
                await db.SaveChangesAsync(stoppingToken);
            }
            catch (Exception ex) when (ex is not OperationCanceledException)
            {
                log.LogError(ex, "Procesarea comenzilor a eșuat");
            }
        }
    }
}

Puncte importante:

  • câte un scope per unitate de lucru: contextul e proaspăt, se eliberează la final și nu păstrează date vechi;
  • CreateAsyncScope cu await using eliberează corect și serviciile IAsyncDisposable;
  • try/catch în buclă: din .NET 6, o excepție neprinsă în ExecuteAsync oprește implicit tot host-ul (BackgroundServiceExceptionBehavior.StopHost);
  • stoppingToken permite oprirea ordonată la deploy.

Același model se aplică oricărui singleton care are nevoie ocazional de un serviciu scoped.

Ce urmărește intervievatorul: Verifică dacă știi să folosești servicii scoped în afara unei cereri HTTP, o problemă reală în orice aplicație cu procesări de fundal. Detaliul despre excepțiile care opresc host-ul arată experiență.

Eroarea, în practică:Cannot resolve scoped service from root provider

39 Mid

Cine apelează Dispose pe serviciile tale și când? Unde poate apărea o scurgere de memorie din cauza containerului?

Răspuns scurt: Containerul eliberează serviciile IDisposable/IAsyncDisposable pe care le-a creat: cele scoped și transient la finalul scope-ului (al cererii), singleton-urile la oprirea aplicației. Scurgerea clasică este un transient disponibil rezolvat din providerul rădăcină: containerul îl ține până la oprire.

Regulile:

  • scoped: eliberat când se termină scope-ul; pentru o cerere HTTP, la finalul cererii;
  • transient: containerul păstrează referința fiecărei instanțe disponibile create într-un scope și o eliberează la finalul acelui scope. Nu e eliberat imediat după folosire;
  • singleton: eliberat la oprirea aplicației, când se eliberează providerul rădăcină;
  • instanțe date de tine (AddSingleton(new X())): nu sunt eliberate de container, pentru că nu le deține.

Scurgerea apare când un transient disponibil este cerut din providerul rădăcină, care trăiește cât aplicația:

C#
app.MapGet("/export", () =>
{
    var exp = app.Services.GetRequiredService<ExportCsv>(); // transient, IDisposable
    return exp.Genereaza();
});

Fiecare cerere creează un ExportCsv pe care rădăcina îl reține pentru Dispose-ul final, deci memoria crește continuu. Corect: îl primești ca parametru ((ExportCsv exp) => ...), adică din scope-ul cererii, sau creezi explicit un scope.

Alte capcane:

  • nu chema Dispose manual pe un serviciu primit din container: altcineva din același scope îl poate folosi în continuare;
  • un serviciu care implementează doar IAsyncDisposable, eliberat sincron (de exemplu un using var scope = CreateScope() simplu), produce InvalidOperationException. Cu CreateAsyncScope și await using nu ai problema;
  • HttpClient creat și eliberat la fiecare apel epuizează socket-urile; folosește IHttpClientFactory (AddHttpClient), care gestionează durata de viață a handler-elor.

Diagnosticul unei scurgeri: dotnet-counters pentru dimensiunea heap-ului, apoi un dump (dotnet-dump) în care cauți câte instanțe ale tipului sunt ținute în viață de ServiceProviderEngineScope.

Ce urmărește intervievatorul: Verifică înțelegerea gestionării resurselor de către container, de unde vin scurgeri reale în producție. Puțini candidați știu că transientele disponibile sunt ținute până la finalul scope-ului.

Eroarea, în practică:Cannot access a disposed object: IServiceProvider

40 Senior

Ce verifică ValidateScopes și ValidateOnBuild? De ce sunt active implicit doar în Development și ce probleme nu prind?

Răspuns scurt: ValidateOnBuild verifică la Build() că fiecare serviciu poate fi construit, fără dependențe lipsă sau captive. ValidateScopes interzice rezolvarea serviciilor scoped din rădăcină. Costă la pornire, de aceea sunt doar în Development, și nu văd în fabrici.

WebApplication.CreateBuilder le activează când mediul este Development. În Production sunt oprite: aplicația pornește mai repede, dar o eroare de înregistrare apare abia când cineva cere serviciul.

Ce prind:

  • ValidateOnBuild: pentru fiecare descriptor, verifică dacă există constructor rezolvabil, dacă toate dependențele sunt înregistrate și dacă un singleton nu depinde de un scoped. Eroarea apare la pornire ca AggregateException: Some services are not able to be constructed (...);
  • ValidateScopes: la rulare, app.Services.GetRequiredService<AppDb>() (scoped, din rădăcină) aruncă Cannot resolve scoped service 'AppDb' from root provider., iar lanțul singleton → scoped este semnalat.

Le poți activa explicit, de exemplu în toate mediile sau în testele de integrare:

C#
builder.Host.UseDefaultServiceProvider(o =>
{
    o.ValidateScopes = true;
    o.ValidateOnBuild = true;
});

Ce nu prind:

  • fabricile: AddSingleton<IRaport>(sp => new Raport(sp.GetRequiredService<AppDb>())) ascunde dependența de scoped. Validarea nu știe ce face lambda-ul;
  • tipurile generice deschise: IRepository<> nu poate fi verificat fără argumentul concret, deci problemele apar la prima rezolvare a lui IRepository<Produs>;
  • service locator: un GetRequiredService<T>() în cod nu se vede din înregistrări;
  • serviciile cerute de handler-e Minimal API care lipsesc sunt prinse de altă validare, la construirea endpoint-urilor, nu de aceasta.

Strategie solidă: validare activă în CI și pre-producție, plus un test de integrare care pornește aplicația în configurația de producție și rezolvă explicit serviciile construite prin fabrici.

Ce urmărește intervievatorul: Verifică dacă știi plasa de siguranță a containerului și limitele ei, deci dacă poți preveni erorile de DI înainte de producție. Seniorii pomenesc fabricile ca punct orb.

Eroarea, în practică:Cannot consume scoped service from singletonSome services are not able to be constructed

Configurare, Options și logging

41 Junior

Ce afișează GET /nume când aplicația rulează în Development cu variabila de mediu Magazin__Nume=DinMediu și argumentul --Magazin:Nume=DinArgument?

JSON
// appsettings.json
{ "Magazin": { "Nume": "DinJson", "Moneda": "RON" } }
// appsettings.Development.json
{ "Magazin": { "Nume": "DinDevelopment" } }
C#
app.MapGet("/nume", (IConfiguration c) => $"{c["Magazin:Nume"]} {c["Magazin:Moneda"]}");

Răspuns scurt: Afișează DinArgument RON. Sursele implicite se suprapun în ordinea appsettings.json, appsettings.{Mediu}.json, user secrets (doar în Development), variabile de mediu, argumente din linia de comandă; ultima care are cheia câștigă, iar cheile lipsă rămân din sursele anterioare.

IConfiguration nu înlocuiește fișiere întregi, ci chei individuale. Fiecare sursă adaugă sau suprascrie valori, iar la citire se caută cheia începând cu ultima sursă adăugată:

1. appsettings.json: Magazin:Nume = DinJson, Magazin:Moneda = RON; 2. appsettings.Development.json: suprascrie Magazin:Nume = DinDevelopment; 3. user secrets (dacă proiectul are UserSecretsId); 4. variabilele de mediu: Magazin__Nume devine Magazin:Nume = DinMediu; 5. argumentele: --Magazin:Nume=DinArgument câștigă.

Moneda nu apare în sursele de după, deci rămâne RON. În Production, fișierul Development nu se încarcă deloc.

Ordinea are sens operațional: fișierele din repository dau valorile implicite, mediul ajustează, iar infrastructura (variabile de mediu în container, argumente la lansare) are ultimul cuvânt fără să modifici imaginea. Sursele adăugate de tine cu builder.Configuration.AddJsonFile("x.json") după CreateBuilder ajung după argumente, deci le suprascriu, ceea ce surprinde des. Dacă vrei ca linia de comandă să rămână ultima, o adaugi din nou cu AddCommandLine(args).

Pentru depanare, ((IConfigurationRoot)builder.Configuration).GetDebugView() afișează fiecare cheie și sursa care a câștigat. Nu îl lăsa activ într-un endpoint public: afișează și secretele.

Ce urmărește intervievatorul: Verifică dacă înțelegi precedența surselor la nivel de cheie, nu doar că există mai multe. Este o întrebare de tip puzzle, diferită de explicarea generală a configurării.

42 Junior

Cum setezi prin variabile de mediu, într-un container, cheile de mai jos?

JSON
{
  "ConnectionStrings": { "Principal": "Server=localhost;Database=magazin" },
  "Logging": { "LogLevel": { "Default": "Information" } },
  "Plati": { "Furnizori": [ "card", "transfer" ] }
}

Răspuns scurt: Înlocuiești : cu dublu underscore: ConnectionStrings__Principal, Logging__LogLevel__Default, iar pentru tablouri folosești indexul: Plati__Furnizori__0, Plati__Furnizori__1. Cheile de configurare nu țin cont de majuscule, deci numele variabilelor nu trebuie să respecte exact capitalizarea.

Separatorul ierarhic din configurare este :, dar multe sisteme nu acceptă : în numele variabilelor de mediu (bash, de exemplu). De aceea providerul de variabile de mediu traduce __ în :.

YAML
# docker-compose.yml
services:
  api:
    image: magazin-api:1.4
    environment:
      ASPNETCORE_ENVIRONMENT: Production
      ConnectionStrings__Principal: "Server=db;Database=magazin;User Id=app;Password=${DB_PAROLA}"
      Logging__LogLevel__Default: Warning
      Plati__Furnizori__0: card
      Plati__Furnizori__1: transfer
      Plati__Furnizori__2: ramburs

Tablourile din configurare sunt de fapt chei numerotate (Plati:Furnizori:0). Variabilele de mediu se suprapun peste JSON element cu element: dacă JSON-ul are trei elemente și setezi doar __0, celelalte două rămân. Nu poți „scurta” un tablou din variabile de mediu, doar suprascrie sau adăuga indexuri.

Detalii utile:

  • builder.Configuration.GetConnectionString("Principal") citește ConnectionStrings:Principal, deci variabila ConnectionStrings__Principal funcționează direct;
  • variabilele cu prefixul ASPNETCORE_ și DOTNET_ sunt citite și pentru configurarea host-ului (ASPNETCORE_ENVIRONMENT, ASPNETCORE_HTTP_PORTS); cu AddEnvironmentVariables("MAGAZIN_") poți citi doar variabilele aplicației, fără prefix în cheie;
  • pe Linux numele variabilelor sunt sensibile la majuscule pentru sistem, dar configurarea .NET le compară fără să țină cont de ele.

În Kubernetes, aceleași nume apar în env sau în envFrom dintr-un ConfigMap/Secret. Parolele vin din Secret, nu scrise în manifest.

Ce urmărește intervievatorul: Verifică experiența de deploy în containere. Cine a lucrat cu Docker știe de __ și de indexurile pentru tablouri; cine nu, încearcă JSON în variabilă.

43 Junior

Ce sunt user secrets? Sunt sigure pentru cheile de producție?

Răspuns scurt: User secrets este un fișier secrets.json din profilul utilizatorului, în afara proiectului, citit de CreateBuilder doar în Development, ca secretele locale să nu ajungă în Git. Nu e criptat și nu e pentru producție, unde folosești variabile de mediu sau un seif.

Pașii:

BASH
dotnet user-secrets init                       # adaugă <UserSecretsId> în csproj
dotnet user-secrets set "Stripe:CheieSecreta" "sk_test_..."
dotnet user-secrets set "ConnectionStrings:Principal" "Server=localhost;..."
dotnet user-secrets list

Valorile ajung în %APPDATA%\Microsoft\UserSecrets\<UserSecretsId>\secrets.json pe Windows sau în ~/.microsoft/usersecrets/<UserSecretsId>/secrets.json pe Linux și macOS. Codul nu se schimbă: citești tot builder.Configuration["Stripe:CheieSecreta"] sau prin Options, iar sursa este adăugată automat după appsettings.{Mediu}.json și înaintea variabilelor de mediu.

Limitele:

  • fișierul este text simplu; protecția vine doar din faptul că stă în profilul tău, nu în repository;
  • se încarcă doar când mediul este Development (sau dacă îl adaugi explicit cu AddUserSecrets<Program>());
  • fiecare coleg își setează propriile valori, deci un README cu cheile necesare ajută.

În producție:

  • variabile de mediu injectate de platformă (setări de aplicație în App Service, Secret în Kubernetes);
  • seif de secrete cu provider de configurare (builder.Configuration.AddAzureKeyVault(...)), cu identitate gestionată, deci fără nicio parolă în configurare;
  • rotația cheilor se face în seif, fără redeploy, dacă aplicația reîncarcă valorile.

Indiferent de sursă, nu loga configurarea întreagă și nu întoarce secrete în răspunsuri de eroare. Dacă o cheie a ajuns deja în Git, ștergerea fișierului nu ajunge: cheia trebuie rotită, pentru că istoricul o păstrează.

Ce urmărește intervievatorul: Verifică igiena secretelor, o temă sensibilă în orice firmă. Răspunsul greșit tipic este că user secrets criptează valorile.

44 Junior

Ce întoarce fiecare linie dacă secțiunea Email lipsește complet din configurare?

C#
var c = builder.Configuration;
var a = c["Email:Host"];
var b = c.GetValue<int>("Email:Port");
var d = c.GetValue("Email:Port", 587);
var e = c.GetSection("Email");
var f = c.GetSection("Email").Get<SetariEmail>();
var g = c.GetRequiredSection("Email");

Răspuns scurt: a este null, b este 0, d este 587, e este o secțiune goală (nu null, dar e.Exists() e false), f este null, iar g aruncă InvalidOperationException. Doar ultima linie te anunță că lipsește configurarea.

Configurarea este, intern, un dicționar de șiruri. Când o cheie lipsește:

  • indexerul c["Email:Host"] întoarce null;
  • GetValue<int> întoarce default(int), adică 0: un port 0 poate trece neobservat până la primul email trimis;
  • GetValue("Email:Port", 587) întoarce valoarea implicită dată de tine;
  • GetSection nu întoarce niciodată null, ci un obiect pentru calea cerută; verifici existența cu Exists();
  • Get<T>() pe o secțiune inexistentă întoarce null, iar pe una parțială creează obiectul și lasă proprietățile lipsă cu valorile implicite;
  • GetRequiredSection aruncă InvalidOperationException: Section 'Email' not found in configuration.

O valoare existentă, dar invalidă ("Port": "abc"), aruncă la GetValue<int> o InvalidOperationException cu mesajul Failed to convert configuration value at 'Email:Port' to type 'System.Int32'.

Consecința practică: citirile tolerante ascund greșeli de configurare (un nume de cheie scris greșit, o variabilă de mediu uitată). Aplicația pornește, iar eroarea apare mult mai târziu, departe de cauză. Pentru setările obligatorii, varianta robustă este Options cu validare la pornire:

C#
builder.Services.AddOptions<SetariEmail>()
    .BindConfiguration("Email")
    .ValidateDataAnnotations()
    .ValidateOnStart();

GetConnectionString("Principal") este doar o scurtătură pentru c["ConnectionStrings:Principal"] și întoarce tot null dacă lipsește.

Ce urmărește intervievatorul: Verifică dacă știi comportamentul exact al API-ului de configurare când lipsesc valori, sursă frecventă de bug-uri tăcute. Candidații buni ajung singuri la validarea la pornire.

Eroarea, în practică:Section not found in configurationFailed to convert configuration value

45 Junior

Ai scris logger.LogDebug(...) în ServiciuComenzi, dar mesajele nu apar în consolă. De ce, și cum le activezi doar pentru această clasă?

JSON
{
  "Logging": {
    "LogLevel": { "Default": "Information", "Microsoft.AspNetCore": "Warning" }
  }
}

Răspuns scurt: Nivelul minim implicit este Information, iar Debug e sub el, deci mesajele sunt filtrate. Adaugi o regulă pentru categoria clasei: categoria unui ILogger<ServiciuComenzi> este numele complet al tipului, de exemplu "Magazin.Comenzi.ServiciuComenzi": "Debug".

Fiecare logger are o categorie. Pentru ILogger<T>, categoria este numele complet al lui T, cu namespace (Magazin.Comenzi.ServiciuComenzi). Regulile din Logging:LogLevel se aplică după cel mai lung prefix potrivit:

JSON
{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning",
      "Magazin.Comenzi": "Debug",
      "Microsoft.EntityFrameworkCore.Database.Command": "Information"
    }
  }
}

Cu regula Magazin.Comenzi, toate clasele din acel namespace scriu de la Debug în sus, iar restul aplicației rămâne la Information. Ultima linie e utilă în dezvoltare: afișează SQL-ul generat de EF Core.

Alte locuri unde se pierd logurile:

  • appsettings.Development.json are propria secțiune Logging, care suprascrie cheile din appsettings.json pentru Development; schimbarea făcută în fișierul greșit nu are efect;
  • poți avea reguli pe provider: "Logging": { "Console": { "LogLevel": { "Default": "Warning" } } } filtrează doar consola;
  • din cod, builder.Logging.SetMinimumLevel(LogLevel.Debug) sau AddFilter("Magazin", LogLevel.Debug); regulile din configurare se aplică și ele, iar cea mai specifică câștigă;
  • o variabilă de mediu precum Logging__LogLevel__Default=Warning pe server suprascrie fișierele.

În producție, nivelul Debug global produce volum mare și costuri de stocare. Activezi detaliile țintit, pe o categorie și temporar; cu reloadOnChange (implicit pentru appsettings.json), schimbarea fișierului se aplică fără repornire.

Ce urmărește intervievatorul: Verifică dacă știi cum funcționează categoriile și filtrele, nu doar apelurile Log.... Greșeala frecventă este modificarea fișierului de configurare care nu se încarcă în mediul curent.

46 Mid

Care este diferența dintre IOptions<T>, IOptionsSnapshot<T> și IOptionsMonitor<T>? Ce se întâmplă cu fiecare când modifici appsettings.json cât timp aplicația rulează?

Răspuns scurt: IOptions<T> este singleton și calculează valoarea o singură dată: nu vede modificările. IOptionsSnapshot<T> este scoped și recalculează valoarea la fiecare cerere. IOptionsMonitor<T> este singleton, dar CurrentValue reflectă mereu ultima configurare și poți reacționa cu OnChange.

Presupunem builder.Services.Configure<SetariLivrare>(builder.Configuration.GetSection("Livrare")), iar appsettings.json se reîncarcă automat la modificare (reloadOnChange: true, implicit).

  • IOptions<SetariLivrare>.Value: creat la primul acces și păstrat cât trăiește aplicația. Modificarea fișierului nu are efect până la repornire. Se poate injecta oriunde, inclusiv în singleton-uri.
  • IOptionsSnapshot<SetariLivrare>.Value: serviciu scoped, recalculat o dată pe cerere; în cadrul aceleiași cereri valoarea rămâne stabilă. Nu poate fi injectat într-un singleton (ar fi o captive dependency, oprită de validarea scope-urilor).
  • IOptionsMonitor<SetariLivrare>.CurrentValue: singleton, cu valoare actualizată când se schimbă sursa; OnChange te anunță.
C#
public class CalculatorLivrare(IOptionsMonitor<SetariLivrare> setari, ILogger<CalculatorLivrare> log)
{
    private readonly IDisposable? _abonare = setari.OnChange(s =>
        log.LogInformation("Prag nou de livrare gratuită: {Prag}", s.PragGratuit));

    public decimal Cost(decimal total) =>
        total >= setari.CurrentValue.PragGratuit ? 0 : setari.CurrentValue.Tarif;
}

Ambele variante „vii” suportă și opțiuni cu nume (Configure<SetariApi>("furnizorA", ...), citite cu Get("furnizorA")), utile când ai aceeași structură pentru mai mulți furnizori.

Alegerea: IOptions pentru setări care nu se schimbă la rulare (cele mai multe); IOptionsSnapshot pentru valori citite în cereri, care trebuie să fie consistente pe durata cererii; IOptionsMonitor în singleton-uri și servicii de fundal care trebuie să reacționeze la schimbări. Atenție: OnChange poate fi apelat de mai multe ori pentru aceeași modificare de fișier, deci codul din el trebuie să fie idempotent.

Ce urmărește intervievatorul: Verifică dacă știi duratele de viață ale variantelor Options și comportamentul la reîncărcare, nu doar existența Options pattern. Greșeala tipică este IOptionsSnapshot injectat într-un singleton.

Eroarea, în practică:Cannot consume IOptionsSnapshot from singleton

47 Mid

Cum te asiguri că aplicația nu pornește dacă lipsesc setările SMTP sau portul e invalid, în loc să afle asta la primul email? Arată două tipuri de validare.

Răspuns scurt: Folosești AddOptions<T>().BindConfiguration("Smtp"), adaugi validări cu ValidateDataAnnotations() și Validate(...) (sau o clasă IValidateOptions<T>), apoi ValidateOnStart(). Fără ValidateOnStart, validarea rulează abia la primul acces la .Value.

C#
builder.Services.AddOptions<SetariSmtp>()
    .BindConfiguration("Smtp")
    .ValidateDataAnnotations()
    .Validate(s => s.Port != 25 || !s.FolosesteTls, "Portul 25 nu se folosește cu TLS.")
    .ValidateOnStart();

public class SetariSmtp
{
    [Required] public string Host { get; set; } = "";
    [Range(1, 65535)] public int Port { get; set; }
    [Required, EmailAddress] public string Expeditor { get; set; } = "";
    public bool FolosesteTls { get; set; } = true;
}

Cu secțiunea lipsă, aplicația se oprește la pornire cu:

Microsoft.Extensions.Options.OptionsValidationException: DataAnnotation validation failed for 'SetariSmtp' members: 'Host' with the error: 'The Host field is required.'.

Fără ValidateOnStart(), aceeași excepție apare la primul IOptions<SetariSmtp>.Value, de obicei în mijlocul unei cereri, ca un 500.

Pentru reguli complexe sau care au nevoie de alte servicii, o clasă dedicată este mai curată:

C#
public class ValidareSmtp : IValidateOptions<SetariSmtp>
{
    public ValidateOptionsResult Validate(string? nume, SetariSmtp s) =>
        s.Host.EndsWith(".local") ? ValidateOptionsResult.Fail("Host-ul nu poate fi .local în producție.")
                                  : ValidateOptionsResult.Success;
}
builder.Services.AddSingleton<IValidateOptions<SetariSmtp>, ValidareSmtp>();

Din .NET 8 există și generatorul [OptionsValidator]: scrii public partial class ValidatorSmtp : IValidateOptions<SetariSmtp> { }, iar codul de validare pentru DataAnnotations este generat la compilare, fără reflection, compatibil cu Native AOT.

Principiul este „fail fast”: o configurare greșită oprește deploy-ul imediat (health check-ul pică, rollout-ul se oprește), în loc să producă erori intermitente ore întregi.

Ce urmărește intervievatorul: Verifică dacă tratezi configurarea ca pe o intrare care trebuie validată. Un candidat bun explică de ce eroarea la pornire e preferabilă uneia la rulare.

Eroarea, în practică:OptionsValidationException: DataAnnotation failedOptionsValidationException: A validation error...

48 Mid

După Bind, proprietatea Port rămâne 0 și Servere rămâne gol, deși appsettings.json are valorile. Unde sunt bug-urile?

JSON
{ "Cache": { "Port": 6379, "Servere": [ "redis1", "redis2" ], "Timeout": "00:00:05" } }
C#
public class SetariCache
{
    public int Port { get; private set; }
    public readonly List<string> Servere = new();
    public TimeSpan Timp { get; set; }
}
var s = builder.Configuration.GetSection("Cache").Get<SetariCache>();

Răspuns scurt: Binder-ul setează doar proprietăți publice cu setter public: Port are private set, Servere este câmp, iar Timp nu se potrivește cu cheia Timeout. Niciuna nu dă eroare: valorile sunt ignorate în tăcere.

ConfigurationBinder parcurge proprietățile publice ale tipului și caută chei cu același nume (fără să țină cont de majuscule). Regulile care explică bug-urile:

  • setter privat: ignorat implicit. Fie faci setter-ul public, fie folosești Get<SetariCache>(o => o.BindNonPublicProperties = true);
  • câmpuri: nu sunt legate deloc; Servere trebuie să fie proprietate: public List<string> Servere { get; set; } = [];
  • nume diferite: Timp nu corespunde lui Timeout, deci rămâne TimeSpan.Zero. Valoarea "00:00:05" ar fi fost convertită corect în TimeSpan dacă numele se potrivea;
  • conversiile de tip care eșuează ("Port": "abc") aruncă InvalidOperationException, singurul caz zgomotos.

Varianta corectă:

C#
public class SetariCache
{
    public int Port { get; set; }
    public List<string> Servere { get; set; } = [];
    public TimeSpan Timeout { get; set; }
}

var s = builder.Configuration.GetSection("Cache")
    .Get<SetariCache>(o => o.ErrorOnUnknownConfiguration = true);

ErrorOnUnknownConfiguration = true aruncă dacă în configurare există chei fără proprietate corespunzătoare, deci prinde exact situația Timeout față de Timp. Combinat cu validarea Options la pornire ([Range(1, 65535)] pe Port, [MinLength(1)] pe Servere), bug-urile de acest tip nu mai ajung în producție.

Din .NET 8, cu <EnableConfigurationBindingGenerator>true</EnableConfigurationBindingGenerator> în csproj, codul de binding este generat la compilare în loc de reflection, util pentru Native AOT și pornire rapidă.

Ce urmărește intervievatorul: Verifică dacă poți depana o configurare care „nu se citește”, foarte frecventă în practică. Se urmărește cunoașterea regulilor binder-ului și a opțiunilor care fac erorile vizibile.

Eroarea, în practică:Cannot create instance: missing parameterless ctor

49 Senior

Ce este generatorul [LoggerMessage] și ce probleme de performanță rezolvă față de logger.LogInformation("...", ...)? Scrie un exemplu.

Răspuns scurt: [LoggerMessage] (.NET 6+) generează la compilare metode de logging puternic tipizate. Șablonul este analizat o singură dată, fără boxing pentru tipurile valoare, fără alocarea tabloului params object[] și cu verificarea IsEnabled înaintea oricărei lucrări. Compilatorul verifică și potrivirea dintre placeholder-e și parametri.

Un apel obișnuit, logger.LogInformation("Comanda {Id} de {Total} lei", id, total), alocă la fiecare apel un object[] pentru argumente și face boxing pentru int și decimal, chiar dacă nivelul Information e dezactivat. Șablonul este interpretat la rulare (cu cache, dar tot costă). Într-un endpoint apelat de mii de ori pe secundă, asta înseamnă presiune pe garbage collector.

Varianta generată:

C#
public static partial class LoguriComenzi
{
    [LoggerMessage(EventId = 1001, Level = LogLevel.Information,
        Message = "Comanda {ComandaId} plasată de {ClientId}, total {Total} lei")]
    public static partial void ComandaPlasata(this ILogger logger, int comandaId, int clientId, decimal total);

    [LoggerMessage(EventId = 1002, Level = LogLevel.Warning,
        Message = "Plata pentru comanda {ComandaId} a fost respinsă")]
    public static partial void PlataRespinsa(this ILogger logger, int comandaId, Exception ex);
}

// folosire
logger.ComandaPlasata(c.Id, c.ClientId, c.Total);
logger.PlataRespinsa(c.Id, ex);

Generatorul scrie corpul metodelor: o structură care păstrează valorile tipizate, verificarea logger.IsEnabled(LogLevel.Information) la început și formatarea doar când mesajul chiar pleacă. Un parametru Exception este transmis automat ca excepție, nu ca placeholder.

Beneficii dincolo de performanță:

  • placeholder-e greșite ({ComandId} fără parametru corespunzător) dau avertismente de compilare;
  • EventId și numele mesajelor sunt centralizate, utile pentru alerte și filtre în sistemul de loguri;
  • codul de business rămâne lizibil: logger.ComandaPlasata(...) spune ce s-a întâmplat.

Nu e nevoie de el pentru fiecare log. Îl folosești pe căile fierbinți și pentru evenimentele importante de business, unde stabilitatea mesajelor contează.

Ce urmărește intervievatorul: Verifică interesul pentru performanță și pentru logging tratat ca un contract. Seniorii știu că problema nu e scrierea logului, ci costul pregătirii lui când nivelul e oprit.

50 Senior

Echipa vrea ca anumite setări (praguri de livrare, mesaje de mentenanță) să fie citite dintr-un tabel din baza de date și să se schimbe fără repornire. Cum ai integra asta în sistemul de configurare?

Răspuns scurt: Scrii un provider de configurare propriu: o clasă ConfigurationProvider care umple dicționarul Data din tabel în Load() și o IConfigurationSource care îl creează, adăugate cu builder.Configuration.Add(...). Pentru schimbări fără repornire, providerul reîncarcă periodic și apelează OnReload(), iar consumatorii folosesc IOptionsMonitor.

Avantajul integrării în IConfiguration este că restul aplicației nu știe de unde vin valorile: citește prin Options ca de obicei, iar precedența surselor rămâne valabilă.

C#
public class SursaDinBaza(string connectionString, TimeSpan interval) : IConfigurationSource
{
    public IConfigurationProvider Build(IConfigurationBuilder builder) =>
        new ProviderDinBaza(connectionString, interval);
}

public sealed class ProviderDinBaza : ConfigurationProvider, IDisposable
{
    private readonly string _cs;
    private readonly Timer _timer;

    public ProviderDinBaza(string cs, TimeSpan interval)
    {
        _cs = cs;
        _timer = new Timer(_ => Reincarca(), null, interval, interval);
    }

    public override void Load() => Data = CitesteSetari();

    private void Reincarca()
    {
        try { Data = CitesteSetari(); OnReload(); }
        catch { /* păstrează valorile vechi dacă baza nu răspunde */ }
    }

    private Dictionary<string, string?> CitesteSetari()
    {
        using var con = new SqlConnection(_cs);
        return con.Query<(string Cheie, string? Valoare)>("SELECT Cheie, Valoare FROM Setari")
            .ToDictionary(r => r.Cheie, r => r.Valoare, StringComparer.OrdinalIgnoreCase);
    }

    public void Dispose() => _timer.Dispose();
}

builder.Configuration.Add(new SursaDinBaza(
    builder.Configuration.GetConnectionString("Principal")!, TimeSpan.FromMinutes(1)));

Cheile din tabel au forma ierarhică obișnuită (Livrare:PragGratuit). OnReload() declanșează change token-ul, deci IOptionsMonitor<SetariLivrare> și IOptionsSnapshot primesc valorile noi.

Decizii de discutat la interviu:

  • pornirea: dacă baza nu răspunde la Load(), aplicația pică sau pornește cu valorile din JSON? Pentru setări critice, valori implicite sigure în appsettings.json;
  • frecvența reîncărcării față de încărcarea bazei, mai ales cu multe instanțe;
  • validarea: valorile noi trec prin aceleași reguli Options; o valoare invalidă nu trebuie să strice aplicația care rulează;
  • audit și cache: cine a schimbat setarea și când.

Pentru feature flags, bibliotecile dedicate (Microsoft.FeatureManagement, Azure App Configuration) rezolvă aceste probleme gata făcute.

Ce urmărește intervievatorul: Verifică dacă înțelegi arhitectura sistemului de configurare suficient de bine cât să-l extinzi, și dacă te gândești la eșecuri. Seniorii discută comportamentul la pornire și validarea valorilor reîncărcate.

Middleware, pipeline și tratarea erorilor

Exersează capitolul cu exerciții reale: Curs ASP.NET Core online →
51 Junior

Ce răspunde aplicația la GET /sanatate, GET /api/x și GET /orice? Care este diferența dintre Use, Run și Map?

C#
var app = WebApplication.Create(args);

app.Map("/sanatate", ramura =>
    ramura.Run(async ctx => await ctx.Response.WriteAsync("OK")));

app.Use(async (ctx, next) =>
{
    ctx.Response.Headers["X-Pas"] = "1";
    await next(ctx);
});

app.Run(async ctx => await ctx.Response.WriteAsync("final"));

app.Run();

Răspuns scurt: /sanatate răspunde OK (ramura creată de Map), iar /api/x și /orice trec prin Use, primesc antetul X-Pas: 1 și corpul final. Use poate continua lanțul, Run îl termină, Map creează o ramură după prefixul căii.

Cele trei metode construiesc pipeline-ul în moduri diferite:

  • Use adaugă un middleware care primește next și decide dacă îl cheamă. Poate face ceva înainte și după restul lanțului.
  • Run adaugă un middleware terminal: nu primește next, deci nimic din ce e înregistrat după el nu mai rulează pentru cererile care ajung acolo.
  • Map("/prefix", ...) desparte pipeline-ul după începutul căii. Cererile care încep cu /sanatate intră în ramură și nu se mai întorc în pipeline-ul principal; pentru ele, Use-ul de mai jos nu rulează, deci nu primesc antetul X-Pas.

Ordinea contează: Map este înregistrat primul, deci ramura este aleasă înainte de Use. Celelalte cereri trec prin Use, care pune antetul și cheamă next, apoi ajung în Run, care scrie final pentru orice cale.

Un detaliu des întrebat: în interiorul ramurii, ctx.Request.Path nu mai conține prefixul (/sanatate/detalii devine /detalii), iar prefixul trece în PathBase. De aceea Map e potrivit pentru sub-aplicații întregi.

Tot ce e după un app.Run(delegat) terminal fără condiție nu mai primește cereri, inclusiv endpoint-urile mapate cu MapGet dacă rutarea ar fi pusă după el. Ultimul app.Run() fără argumente nu este middleware: pornește serverul.

Ce urmărește intervievatorul: Verifică dacă știi să citești un pipeline și ce înseamnă un middleware terminal. Mulți candidați cred că Map se întoarce în pipeline-ul principal după ramură.

52 Junior

Scrie un middleware care respinge cu 401 orice cerere către /api care nu are antetul X-Api-Key cu valoarea corectă. Ce înseamnă că un middleware „scurtcircuitează” pipeline-ul?

Răspuns scurt: Middleware-ul verifică antetul și, dacă lipsește sau e greșit, setează StatusCode = 401 și nu cheamă next. Asta e scurtcircuitarea: restul pipeline-ului (rutare, endpoint) nu mai rulează pentru acea cerere.

Un middleware inline cu app.Use primește contextul și următorul delegat. Dacă nu îl cheamă, răspunsul pleacă direct de acolo:

C#
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
var cheie = app.Configuration["ApiKey"];

app.Use(async (ctx, next) =>
{
    if (ctx.Request.Path.StartsWithSegments("/api"))
    {
        var primita = ctx.Request.Headers["X-Api-Key"].ToString();
        if (string.IsNullOrEmpty(cheie) || primita != cheie)
        {
            ctx.Response.StatusCode = StatusCodes.Status401Unauthorized;
            await ctx.Response.WriteAsync("Cheie API lipsă sau invalidă");
            return; // scurtcircuitare: next nu mai rulează
        }
    }
    await next(ctx);
});

app.MapGet("/api/produse", () => new[] { "Mouse", "Tastatură" });
app.MapGet("/", () => "Public");
app.Run();

Detalii care contează la interviu:

  • StartsWithSegments("/api") potrivește /api și /api/produse, dar nu /apiuri, spre deosebire de StartsWith.
  • Cheia vine din configurare (variabilă de mediu sau secret), nu e scrisă în cod.
  • Middleware-ul trebuie înregistrat înainte de endpoint-uri ca să le protejeze.
  • Scurtcircuitarea e și o optimizare: fișierele statice, health check-urile sau un cache răspund devreme, fără să mai treacă prin tot lanțul.

Într-o aplicație reală, pentru utilizatori ai folosi autentificarea și autorizarea framework-ului, dar o cheie API simplă pentru integrări interne este un caz clasic de middleware propriu.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi să oprești lanțul corect (fără next după ce ai scris răspunsul) și că folosești StartsWithSegments. Greșeala tipică: chemi next și după ce ai scris 401.

53 Junior

Cum scrii un middleware ca clasă? De ce codul de mai jos are o problemă, deși compilează?

C#
public class AuditMiddleware
{
    private readonly RequestDelegate _next;
    private readonly AppDbContext _db;

    public AuditMiddleware(RequestDelegate next, AppDbContext db)
    {
        _next = next;
        _db = db;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _db.Audit.Add(new Intrare(context.Request.Path));
        await _db.SaveChangesAsync();
        await _next(context);
    }
}

Răspuns scurt: Middleware-ul convențional este creat o singură dată, la pornire, deci ce primește în constructor trăiește cât aplicația. Un DbContext scoped primit acolo devine captiv. Serviciile scoped se cer ca parametri ai lui InvokeAsync.

Un middleware convențional are trei elemente: un constructor public care primește RequestDelegate next, o metodă Invoke sau InvokeAsync care primește HttpContext și întoarce Task, și înregistrarea cu app.UseMiddleware<AuditMiddleware>().

Framework-ul construiește instanța o dată, când se construiește pipeline-ul. Constructorul poate primi doar servicii singleton (sau transient care devin practic singleton). În Development, injectarea unui DbContext acolo dă eroarea Cannot resolve scoped service 'AppDbContext' from root provider; în alte configurații ajungi la un singur context folosit de toate cererile, în paralel, ceea ce aruncă erori de concurență și ține în memorie toate entitățile urmărite.

Varianta corectă primește serviciile scoped prin InvokeAsync, unde sunt rezolvate din scope-ul cererii curente:

C#
public class AuditMiddleware(RequestDelegate next)
{
    public async Task InvokeAsync(HttpContext context, AppDbContext db)
    {
        db.Audit.Add(new Intrare(context.Request.Path));
        await db.SaveChangesAsync();
        await next(context);
    }
}

// Program.cs
app.UseMiddleware<AuditMiddleware>();

Ce primește constructorul este partajat între cereri, deci trebuie să fie thread-safe; ce primește InvokeAsync este specific cererii. Alternativa este IMiddleware, unde chiar clasa middleware-ului are o durată de viață din DI.

Ce urmărește intervievatorul: Verifică dacă înțelegi că middleware-ul convențional e practic singleton. Mulți candidați injectează repository-uri scoped în constructor fără să știe de ce apar erori.

Eroarea, în practică:Cannot resolve scoped service from root provider

54 Junior

Care este diferența dintre MapWhen și UseWhen? Ce primește clientul la GET /admin/rapoarte?debug=1 în fiecare variantă?

C#
// Varianta A
app.MapWhen(ctx => ctx.Request.Query.ContainsKey("debug"),
    ramura => ramura.Use(async (ctx, next) =>
    {
        ctx.Response.Headers["X-Debug"] = "on";
        await next(ctx);
    }));

// Varianta B
app.UseWhen(ctx => ctx.Request.Query.ContainsKey("debug"),
    ramura => ramura.Use(async (ctx, next) =>
    {
        ctx.Response.Headers["X-Debug"] = "on";
        await next(ctx);
    }));

app.MapGet("/admin/rapoarte", () => "raport");

Răspuns scurt: MapWhen creează o ramură separată care nu se mai întoarce în pipeline-ul principal: în varianta A, cererea primește X-Debug, dar 404, pentru că endpoint-ul nu e în ramură. UseWhen rulează ramura și apoi revine: în B primește antetul și raport.

Ambele metode aleg o ramură după un predicat pe HttpContext (orice condiție: query, antet, metodă, utilizator), spre deosebire de Map, care se uită doar la prefixul căii. Diferența este ce se întâmplă după ramură.

MapWhen desparte pipeline-ul definitiv: ramura are propriul ei lanț, care se termină în ramură. Când middleware-ul din ramură cheamă next și nu mai urmează nimic, se ajunge la capătul ramurii, care răspunde 404. Endpoint-ul /admin/rapoarte din pipeline-ul principal nu e niciodată atins pentru cererile cu debug. Varianta A e potrivită când ramura răspunde complet singură (de exemplu o pagină de diagnostic).

UseWhen adaugă condiționat câțiva pași, apoi cererea revine în pipeline-ul principal. E potrivit pentru „middleware doar pentru unele cereri”: logare detaliată pentru /api, decompresie pentru un anumit Content-Type, o verificare suplimentară pentru un grup de căi.

Regula ca să nu greșești: dacă ramura trebuie să ajungă tot la endpoint-urile tale, folosește UseWhen. Și ține minte că o ramură UseWhen care nu cheamă next scurtcircuitează la fel ca orice middleware.

Ce urmărește intervievatorul: Întrebarea arată dacă ai lucrat efectiv cu ramuri de pipeline. Candidații care confundă cele două metode ajung la 404-uri greu de explicat.

55 Junior

Ce vede clientul când un endpoint aruncă o excepție neprinsă, în Development și în Production? Ce face app.UseExceptionHandler("/eroare")?

Răspuns scurt: În Development, WebApplication adaugă automat Developer Exception Page: 500 cu tipul excepției și stack trace-ul. În Production, fără configurare, clientul primește doar 500 fără corp. UseExceptionHandler prinde excepția și re-execută cererea pe calea de eroare, unde scrii un răspuns controlat.

De la .NET 6, WebApplication pune singur UseDeveloperExceptionPage() la începutul pipeline-ului când mediul este Development. Pagina afișează tipul excepției, mesajul, stack trace-ul, antetele și query-ul: excelentă local, periculoasă dacă ar ajunge în producție, pentru că dezvăluie structura codului.

În Production nu există pagina de dezvoltator. Kestrel prinde excepția, o loghează și răspunde 500 cu corp gol, dacă răspunsul nu a început deja. Clientul nu află nimic util, dar nici nu vede detalii interne.

Configurația obișnuită:

C#
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/eroare");
}

app.Map("/eroare", (HttpContext ctx) =>
{
    var ex = ctx.Features.Get<IExceptionHandlerFeature>()?.Error;
    return Results.Problem(title: "A apărut o eroare. Încearcă din nou.",
                           statusCode: 500);
});

UseExceptionHandler învelește restul pipeline-ului într-un try/catch. La excepție, golește răspunsul, schimbă calea cererii în /eroare și rulează din nou pipeline-ul de după el; excepția originală rămâne disponibilă prin IExceptionHandlerFeature, ca s-o poți loga sau mapa.

Două capcane: middleware-ul trebuie pus primul, ca să prindă erorile din tot ce urmează, iar calea de eroare nu trebuie să fie protejată de autorizare sau limitată doar la GET, altfel re-execuția unui POST eșuează și clientul primește tot un 500 gol.

Ce urmărește intervievatorul: Verifică dacă știi diferența de comportament între medii și cum funcționează re-execuția. Mulți nu știu că pagina de dezvoltator este adăugată automat.

Eroarea, în practică:An unhandled exception has occurred (500)Error when configuring the exception handler

56 Mid

Care este diferența dintre un middleware convențional și unul care implementează IMiddleware? Ce durată de viață poate avea fiecare?

Răspuns scurt: Middleware-ul convențional e creat o dată de pipeline și primește serviciile scoped în InvokeAsync. Un IMiddleware este rezolvat din DI la fiecare cerere, cu durata de viață cu care l-ai înregistrat, deci poate primi servicii scoped direct în constructor.

Middleware-ul convențional (clasă cu RequestDelegate next în constructor) este activat de UseMiddleware<T>() prin ActivatorUtilities, o singură dată. Nu trebuie înregistrat în DI. Constructorul primește doar ce se poate rezolva din containerul rădăcină, iar dependențele per cerere vin ca parametri suplimentari ai lui InvokeAsync.

IMiddleware are o singură metodă, InvokeAsync(HttpContext context, RequestDelegate next). Framework-ul folosește IMiddlewareFactory, care cere instanța din scope-ul cererii, deci trebuie să o înregistrezi:

C#
public class MasurareTimp(ILogger<MasurareTimp> log, IOra ora) : IMiddleware
{
    public async Task InvokeAsync(HttpContext ctx, RequestDelegate next)
    {
        var start = ora.Acum();
        await next(ctx);
        log.LogInformation("{Cale} a durat {Ms} ms", ctx.Request.Path,
            (ora.Acum() - start).TotalMilliseconds);
    }
}

builder.Services.AddScoped<MasurareTimp>();
app.UseMiddleware<MasurareTimp>();

Dacă uiți AddScoped/AddTransient, aplicația pornește, dar prima cerere aruncă InvalidOperationException că tipul nu poate fi creat de factory.

Când alegi IMiddleware: când middleware-ul are multe dependențe scoped și vrei constructor injection obișnuit, ușor de testat. Prețul e o rezolvare din DI la fiecare cerere. Convenționalul e puțin mai rapid și e alegerea implicită pentru middleware-uri simple sau fără stare. Ambele variante pot fi singleton doar dacă sunt thread-safe.

Ce urmărește intervievatorul: Întrebarea separă candidații care au scris middleware-uri reale. Greșeala tipică: a uita înregistrarea în DI pentru IMiddleware sau a crede că middleware-ul convențional e scoped.

Eroarea, în practică:No public 'Invoke' or 'InvokeAsync' method foundInvoke first argument must be of type HttpContext

57 Mid

Unde este bug-ul? În loguri apare System.InvalidOperationException: Headers are read-only, response has already started.

C#
app.Use(async (ctx, next) =>
{
    var start = TimeProvider.System.GetTimestamp();
    await next(ctx);
    var ms = TimeProvider.System.GetElapsedTime(start).TotalMilliseconds;
    ctx.Response.Headers["X-Durata-Ms"] = ms.ToString();
});

Răspuns scurt: După await next(ctx), endpoint-ul a scris deja corpul, iar antetele au fost trimise clientului. Nu mai poți modifica antetele. Le adaugi într-un callback Response.OnStarting, care rulează chiar înainte de trimiterea lor, sau verifici Response.HasStarted.

HTTP trimite întâi linia de status și antetele, apoi corpul. Când endpoint-ul începe să scrie corpul (WriteAsync, WriteAsJsonAsync, un rezultat JSON), Kestrel trimite antetele pe rețea. Din acel moment Response.HasStarted devine true, iar colecția de antete devine read-only. Codul de după next rulează prea târziu.

Varianta corectă înregistrează o acțiune care rulează exact înainte de trimiterea antetelor:

C#
app.Use(async (ctx, next) =>
{
    var start = TimeProvider.System.GetTimestamp();
    ctx.Response.OnStarting(() =>
    {
        var ms = TimeProvider.System.GetElapsedTime(start).TotalMilliseconds;
        ctx.Response.Headers["X-Durata-Ms"] = ms.ToString("0");
        return Task.CompletedTask;
    });
    await next(ctx);
});

Atenție: durata măsurată astfel este până la primul octet trimis, nu până la sfârșitul răspunsului. Pentru durata completă, scrii valoarea în log după next, nu într-un antet.

Aceeași regulă se aplică și pentru StatusCode: un middleware de erori care vrea să schimbe codul după ce corpul a început nu mai poate. De aceea UseExceptionHandler verifică HasStarted și, dacă răspunsul a început, doar loghează și închide conexiunea. Când scrii middleware care modifică răspunsul, întreabă-te mereu dacă rulează înainte sau după ce a pornit corpul.

Ce urmărește intervievatorul: Verifică înțelegerea modului în care se trimite un răspuns HTTP. Candidații care nu știu de OnStarting ajung la erori intermitente, mai ales cu răspunsuri mici puse în buffer.

Eroarea, în practică:Headers are read-only, response has already startedStatusCode cannot be set: response already started

58 Mid

Cum folosești IExceptionHandler (.NET 8) ca să transformi excepțiile de domeniu în răspunsuri ProblemDetails cu codul potrivit? Scrie un exemplu pentru ProdusInexistentException → 404 și StocInsuficientException → 409.

Răspuns scurt: Implementezi IExceptionHandler.TryHandleAsync, mapezi tipul excepției la un cod de status, scrii ProblemDetails și întorci true. Înregistrezi cu AddExceptionHandler<T>() și AddProblemDetails(), iar în pipeline pui app.UseExceptionHandler().

Înainte de .NET 8, maparea se făcea într-un middleware propriu cu try/catch sau într-o lambda la UseExceptionHandler. IExceptionHandler oferă un punct de extensie curat, înregistrat în DI și ușor de testat:

C#
public class HandlerDomeniu(IProblemDetailsService pds) : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(HttpContext ctx, Exception ex, CancellationToken ct)
    {
        var (status, titlu) = ex switch
        {
            ProdusInexistentException => (404, "Produsul nu există"),
            StocInsuficientException => (409, "Stoc insuficient"),
            _ => (0, "")
        };
        if (status == 0) return false; // lasă alt handler sau comportamentul implicit

        ctx.Response.StatusCode = status;
        return await pds.TryWriteAsync(new ProblemDetailsContext
        {
            HttpContext = ctx,
            ProblemDetails = { Status = status, Title = titlu, Detail = ex.Message }
        });
    }
}

builder.Services.AddExceptionHandler<HandlerDomeniu>();
builder.Services.AddProblemDetails();
// ...
app.UseExceptionHandler();

Puncte importante:

  • Handlerele sunt singleton și se apelează în ordinea înregistrării; primul care întoarce true câștigă. Pune unul general la final pentru 500.
  • UseExceptionHandler() fără cale și fără delegat are nevoie de AddProblemDetails(), altfel aplicația aruncă InvalidOperationException la pornire.
  • IProblemDetailsService respectă CustomizeProblemDetails și negocierea conținutului, deci toate erorile au același format.

O întrebare suplimentară frecventă: este bine să folosești excepții pentru 404? Pentru cazuri așteptate, un rezultat (Results.NotFound()) e mai ieftin și mai explicit; maparea excepțiilor e plasa de siguranță pentru regulile de domeniu adânci în servicii.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi API-ul modern din .NET 8 și ordinea de înregistrare. Un răspuns bun menționează și când nu folosești excepții pentru controlul fluxului.

Eroarea, în practică:An error occurred while processing your request

59 Mid

Un client se plânge că GET /api/produse/999 și GET /api/nu-exista răspund 404 cu corp gol și nu știe ce s-a întâmplat. Ce fac UseStatusCodePages și AddProblemDetails în această situație?

Răspuns scurt: UseStatusCodePages completează răspunsurile de eroare 400–599 care nu au corp, de exemplu cu un text sau, împreună cu AddProblemDetails, cu un obiect ProblemDetails. Nu atinge răspunsurile care au deja corp și nici pe cele de succes.

Un 404 fără corp apare în două cazuri: nicio rută nu se potrivește (rutarea nu găsește endpoint) sau endpoint-ul întoarce Results.NotFound() fără argument. Pentru un API e mai prietenos un corp standard, ca orice client să parseze același format.

C#
builder.Services.AddProblemDetails();
var app = builder.Build();

app.UseExceptionHandler();
app.UseStatusCodePages();

app.MapGet("/api/produse/{id:int}", (int id) =>
    id == 1 ? Results.Ok(new { id, nume = "Mouse" }) : Results.NotFound());

Cu ambele configurate, GET /api/produse/999 primește Content-Type: application/problem+json și un corp de forma {"type":"https://tools.ietf.org/html/rfc9110#section-15.5.5","title":"Not Found","status":404}. Fără AddProblemDetails, UseStatusCodePages scrie un text simplu: Status Code: 404; Not Found.

Ce trebuie să știi:

  • Middleware-ul se uită la răspuns la ieșire: dacă statusul e de eroare, corpul e gol și răspunsul nu a început, scrie el corpul.
  • Dacă endpoint-ul scrie singur un corp (Results.NotFound("Produsul 999 nu există")), răspunsul rămâne cum l-a scris.
  • Variantele UseStatusCodePagesWithReExecute("/eroare/{0}") și WithRedirects sunt pentru aplicații cu pagini HTML; într-un API, redirectul la o pagină de eroare e greșit.
  • Controllerele cu [ApiController] produc deja ProblemDetails pentru NotFound() fără argument, prin ClientErrorMapping.

Ce urmărește intervievatorul: Verifică dacă știi să obții erori consistente pentru clienți. Mulți candidați cred că trebuie să scrie manual corpul la fiecare 404.

Eroarea, în practică:404 Not Found: nicio rută potrivită

60 Senior

Trebuie să salvezi în jurnalul de audit corpul fiecărei cereri POST către /api/plati, într-un middleware, înainte de endpoint. De ce nu merge citirea directă a lui Request.Body și cum o faci corect, fără să strici endpoint-ul sau performanța?

Răspuns scurt: Request.Body e un stream care se citește o singură dată: dacă middleware-ul îl consumă, endpoint-ul primește un corp gol. Apelezi Request.EnableBuffering(), citești, readuci Position = 0 și limitezi dimensiunea. Pentru volume mari, folosești logarea HTTP din framework.

Kestrel expune corpul ca un stream de rețea, fără poziționare. După ce l-ai citit până la capăt, binding-ul din endpoint nu mai are ce citi și dă 400 („Failed to read parameter... from the request body as JSON”) sau un obiect gol.

EnableBuffering înlocuiește stream-ul cu unul care ține în memorie primii 30 KB și restul într-un fișier temporar, și care permite Seek:

C#
app.UseWhen(ctx => HttpMethods.IsPost(ctx.Request.Method)
                   && ctx.Request.Path.StartsWithSegments("/api/plati"),
    ramura => ramura.Use(async (ctx, next) =>
    {
        ctx.Request.EnableBuffering(bufferLimit: 64 * 1024);
        using var cititor = new StreamReader(ctx.Request.Body, leaveOpen: true);
        var corp = await cititor.ReadToEndAsync(ctx.RequestAborted);
        ctx.Request.Body.Position = 0;

        var audit = ctx.RequestServices.GetRequiredService<IAudit>();
        await audit.ScrieAsync(ctx.Request.Path, Mascheaza(corp));
        await next(ctx);
    }));

Decizii pe care le explici la nivel senior:

  • leaveOpen: true, altfel StreamReader închide stream-ul și endpoint-ul primește ObjectDisposedException.
  • Limitezi cererile pe care le auditezi și dimensiunea (bufferLimit, MaxRequestBodySize), ca un client să nu-ți umple memoria sau discul.
  • Datele de plată sunt sensibile: maschezi numere de card, CVV, tokenuri înainte de scriere (cerințe PCI DSS, GDPR).
  • Scrierea în audit poate fi trimisă într-o coadă (Channel<T> + BackgroundService) ca să nu crească latența.
  • Pentru diagnostic general există AddHttpLogging cu HttpLoggingFields.RequestBody și RequestBodyLogLimit, care rezolvă buffering-ul pentru tine.

Ce urmărește intervievatorul: La nivel senior se verifică înțelegerea stream-urilor și compromisurile de securitate și performanță. Greșeala tipică: citești corpul fără buffering sau loghezi date de card în clar.

Controllere, filtre și validare

61 Junior

Ce schimbă concret atributul [ApiController] pe un controller? Enumeră comportamentele pe care le adaugă.

Răspuns scurt: Face rutarea prin atribute obligatorie, răspunde automat cu 400 ValidationProblemDetails când modelul e invalid, deduce sursa parametrilor ([FromBody] pentru tipuri complexe, [FromRoute], [FromQuery]) și transformă erorile 4xx fără corp în ProblemDetails.

[ApiController] activează un set de convenții gândite pentru API-uri HTTP, nu pentru pagini:

  • Rutare prin atribute obligatorie: acțiunile trebuie să aibă [Route]/[HttpGet("...")]; rutele convenționale de tip {controller}/{action} nu se aplică.
  • 400 automat: un filtru (ModelStateInvalidFilter) verifică ModelState înainte de acțiune și, dacă e invalid, răspunde imediat cu ValidationProblemDetails. Acțiunea nu mai rulează, deci nu mai scrii if (!ModelState.IsValid).
  • Deducerea sursei de binding: tipurile complexe vin din corp, parametrii cu același nume ca în șablonul rutei din rută, restul din query; IFormFile din formular; serviciile înregistrate în DI sunt deduse ca [FromServices].
  • ProblemDetails pentru erorile clientului: return NotFound(); produce un corp application/problem+json cu type, title, status și traceId.
C#
[ApiController]
[Route("api/[controller]")]
public class ProduseController : ControllerBase
{
    [HttpPost]
    public ActionResult<Produs> Creeaza(ProdusNou date) // date vine din corp, validat automat
        => CreatedAtAction(nameof(GetById), new { id = 1 }, new Produs(1, date.Nume));

    [HttpGet("{id:int}")]
    public ActionResult<Produs> GetById(int id) => NotFound();
}

Atributul se poate pune pe un controller de bază sau pe assembly ([assembly: ApiController]). Fiecare comportament se poate dezactiva din ConfigureApiBehaviorOptions, de exemplu SuppressModelStateInvalidFilter = true dacă vrei să validezi manual.

Ce urmărește intervievatorul: Verifică dacă știi ce face framework-ul în locul tău. Candidații slabi spun doar „marchează controllerul ca API”, fără niciun comportament concret.

Eroarea, în practică:One or more validation errors occurred. (400)The X field is required.

62 Junior

Care este diferența între aceste trei semnături de acțiune? Pe care ai alege-o pentru GET api/produse/{id}?

C#
public Produs Get1(int id) { ... }
public IActionResult Get2(int id) { ... }
public ActionResult<Produs> Get3(int id) { ... }

Răspuns scurt: Produs poate întoarce doar 200 cu obiectul. IActionResult poate întoarce orice cod, dar pierde tipul în semnătură. ActionResult<Produs> le combină: poți întoarce direct produs (200) sau NotFound(), iar tipul rămâne vizibil pentru OpenAPI.

Toate trei funcționează, dar exprimă lucruri diferite.

Produs Get1 întoarce mereu 200 (sau 204 dacă valoarea e null, comportament implicit al formatter-ului). Nu poți spune „nu există” fără să arunci o excepție.

IActionResult Get2 lasă orice rezultat: Ok(produs), NotFound(), BadRequest(). Dezavantajul: semnătura nu mai spune ce tip are corpul, deci generatorul OpenAPI și cititorul codului au nevoie de [ProducesResponseType(typeof(Produs), 200)].

ActionResult<Produs> Get3 are conversii implicite atât din Produs, cât și din ActionResult:

C#
[HttpGet("{id:int}")]
public ActionResult<Produs> Get(int id)
{
    var produs = _repo.Gaseste(id);
    if (produs is null)
        return NotFound();   // ActionResult
    return produs;           // Produs -> 200 OK
}

Pentru cazul din întrebare, ActionResult<Produs> este alegerea obișnuită: cod clar, tipul documentat automat, iar return produs; nu mai are nevoie de Ok(...).

O capcană: conversia implicită nu funcționează cu interfețe. ActionResult<IEnumerable<Produs>> nu acceptă return lista; dacă lista e List<Produs>, pentru că C# nu permite operatori de conversie definiți de utilizator din sau către interfețe; scrii return Ok(lista); sau schimbi tipul în ActionResult<List<Produs>>. În Minimal APIs, echivalentul este Results<Ok<Produs>, NotFound>.

Ce urmărește intervievatorul: Verifică dacă știi să alegi tipul de retur pentru a documenta API-ul. Capcana cu interfețele apare des în code review.

Eroarea, în practică:CS0029: IEnumerable<T> to ActionResult<T>

63 Junior

După un POST, clientul primește 201, dar fără antetul Location, sau aplicația aruncă No route matches the supplied values. Unde e greșeala?

C#
[HttpGet("{id:int}")]
public async Task<ActionResult<Comanda>> GetComandaAsync(int id) { ... }

[HttpPost]
public async Task<ActionResult<Comanda>> Creeaza(ComandaNoua date)
{
    var c = await _servicii.CreeazaAsync(date);
    return CreatedAtAction(nameof(GetComandaAsync), new { id = c.Id }, c);
}

Răspuns scurt: MVC elimină implicit sufixul Async din numele acțiunilor, deci acțiunea se numește GetComanda, iar nameof(GetComandaAsync) nu o găsește. Repari cu [ActionName(nameof(GetComandaAsync))], cu SuppressAsyncSuffixInActionNames = false sau scriind numele fără sufix.

CreatedAtAction(numeActiune, valoriRuta, corp) produce un răspuns 201 cu corpul dat și cu antetul Location generat de LinkGenerator din ruta acțiunii indicate, de exemplu https://localhost:5001/api/comenzi/42. Pentru asta trebuie să găsească acțiunea după nume, în același controller (sau în altul, cu parametrul controllerName), și toate valorile cerute de șablonul rutei.

Din ASP.NET Core 3.0, opțiunea MvcOptions.SuppressAsyncSuffixInActionNames este true: metoda GetComandaAsync devine acțiunea GetComanda. nameof(GetComandaAsync) produce textul "GetComandaAsync", care nu corespunde niciunei acțiuni, iar generarea linkului eșuează cu InvalidOperationException: No route matches the supplied values.

Variante de reparare:

C#
[HttpGet("{id:int}")]
[ActionName(nameof(GetComandaAsync))]
public async Task<ActionResult<Comanda>> GetComandaAsync(int id) { ... }

sau, global, builder.Services.AddControllers(o => o.SuppressAsyncSuffixInActionNames = false);. A treia cale, mai robustă la redenumiri: dai rutei un nume, [HttpGet("{id:int}", Name = "GetComanda")], și folosești CreatedAtRoute("GetComanda", new { id = c.Id }, c).

A doua greșeală frecventă este un nume greșit în obiectul de valori (new { comandaId = c.Id } când ruta are {id}): valoarea care nu se potrivește ajunge în query, iar parametrul obligatoriu lipsește.

Ce urmărește intervievatorul: Întrebarea verifică experiența practică: bug-ul cu sufixul Async este întâlnit de aproape oricine scrie controllere asincrone.

Eroarea, în practică:No route matches the supplied values

64 Junior

O rezervare are DataSosire și DataPlecare. Cum validezi că plecarea este după sosire, astfel încât un controller cu [ApiController] să răspundă automat 400 cu un mesaj clar?

Răspuns scurt: Implementezi IValidatableObject pe modelul cererii și întorci un ValidationResult cu numele proprietății implicate. MVC îl apelează după atributele de validare, iar [ApiController] transformă erorile în 400 ValidationProblemDetails.

Atributele precum [Required] sau [Range] validează câte o proprietate. Pentru regulile care leagă mai multe câmpuri ai două opțiuni: un atribut pe clasă sau IValidatableObject. A doua e mai simplă și ține regula lângă date:

C#
public class RezervareNoua : IValidatableObject
{
    [Required] public string Camera { get; set; } = "";
    public DateOnly DataSosire { get; set; }
    public DateOnly DataPlecare { get; set; }

    public IEnumerable<ValidationResult> Validate(ValidationContext context)
    {
        if (DataPlecare <= DataSosire)
            yield return new ValidationResult(
                "Data plecării trebuie să fie după data sosirii.",
                new[] { nameof(DataPlecare) });
    }
}

Răspunsul pentru o cerere invalidă arată astfel:

JSON
{"title":"One or more validation errors occurred.","status":400,
 "errors":{"DataPlecare":["Data plecării trebuie să fie după data sosirii."]}}

Detalii care contează:

  • Validate rulează doar dacă atributele de pe proprietăți au trecut, deci nu vei primi ambele tipuri de erori deodată.
  • Al doilea argument al lui ValidationResult alege cheia din errors; fără el, eroarea apare sub cheia goală "", greu de afișat de client.
  • Regulile care au nevoie de baza de date („camera e liberă?”) nu stau în model: le verifici în serviciu și întorci 409 Conflict, pentru că nu sunt erori de format.

Pentru reguli numeroase, multe echipe folosesc FluentValidation, care separă validatorii de model și se testează ușor.

Ce urmărește intervievatorul: Verifică dacă știi să faci validare între câmpuri fără cod repetat în acțiune. Un candidat bun separă validarea de format de regulile de business.

Eroarea, în practică:'X' and 'Y' do not match.

65 Junior

De ce răspunde acțiunea de mai jos cu 415 Unsupported Media Type la GET api/produse?categorie=it&pretMax=500?

C#
[ApiController]
[Route("api/produse")]
public class ProduseController : ControllerBase
{
    [HttpGet]
    public IActionResult Cauta(FiltruProduse filtru) => Ok(filtru);
}

public record FiltruProduse(string? Categorie, decimal? PretMax);

Răspuns scurt: [ApiController] deduce că un tip complex vine din corp ([FromBody]). Cererea GET nu are corp și nici Content-Type: application/json, deci formatter-ul refuză cu 415. Pui [FromQuery] pe parametru și obiectul se construiește din query string.

Regulile de deducere ale lui [ApiController] sunt simple: tipurile simple (numere, string, Guid, DateTime) vin din rută dacă numele apare în șablon, altfel din query; tipurile complexe vin din corp. Pentru corp, MVC alege un input formatter după Content-Type. Un GET fără corp nu are acest antet, deci niciun formatter nu se potrivește și răspunsul e 415, înainte să ruleze acțiunea.

Repararea:

C#
[HttpGet]
public IActionResult Cauta([FromQuery] FiltruProduse filtru) => Ok(filtru);

Acum model binding-ul MVC construiește obiectul din ?categorie=it&pretMax=500, cu potrivire de nume fără să conteze majusculele, inclusiv pentru parametrii constructorului unui record. O valoare invalidă (pretMax=ieftin) adaugă o eroare în ModelState și produce 400 automat, cu cheia PretMax.

Diferența față de Minimal APIs: acolo un tip complex într-un MapGet fără atribut nu ajunge la 415, ci aplicația nu pornește (Body was inferred but the method does not allow inferred body parameters), iar echivalentul lui [FromQuery] pentru obiecte este [AsParameters].

Regula practică: pentru filtre, paginare și sortare în GET, pune întotdeauna [FromQuery] explicit pe obiectul de filtru; nu te baza pe deducere, pentru că ea alege corpul.

Ce urmărește intervievatorul: Verifică dacă știi regulile de deducere a sursei. Candidații care nu le cunosc caută bug-ul în client, nu în server.

66 Mid

Ce tipuri de filtre există în MVC și în ce ordine rulează? În ce ordine apar mesajele dacă un filtru global, unul pe controller și unul pe acțiune scriu în consolă în OnActionExecuting și OnActionExecuted?

Răspuns scurt: Ordinea pe tipuri este: authorization, resource, (model binding), action, acțiunea, apoi exception și result. La același tip, OnActionExecuting rulează global → controller → acțiune, iar OnActionExecuted în ordine inversă, ca niște cutii una în alta. Order schimbă ordinea.

Filtrele sunt pipeline-ul din interiorul MVC, după ce rutarea a ales acțiunea:

  • Authorization (IAuthorizationFilter): primele; pot opri cererea cu 401/403.
  • Resource (IResourceFilter): înainte și după model binding; bune pentru cache sau pentru a opri cererea devreme.
  • Action (IActionFilter): în jurul acțiunii, cu argumentele deja legate.
  • Exception (IExceptionFilter): prind excepțiile din acțiune și din filtrele de acțiune, nu și din middleware.
  • Result (IResultFilter): în jurul execuției rezultatului (scrierea corpului), doar dacă acțiunea a produs un rezultat.

Pentru filtre de același tip, domeniul decide ordinea, cu imbricare:

Global.OnActionExecuting
Controller.OnActionExecuting
Actiune.OnActionExecuting
  -> acțiunea rulează
Actiune.OnActionExecuted
Controller.OnActionExecuted
Global.OnActionExecuted

Proprietatea Order (din IOrderedFilter) are prioritate față de domeniu: valorile mai mici rulează primele la intrare. Toate filtrele au implicit Order = 0, de aceea contează domeniul.

Un detaliu des întrebat: un controller care moștenește Controller (nu doar ControllerBase) poate suprascrie OnActionExecuting, iar acel cod rulează ca cel mai exterior filtru de acțiune pentru acel controller. Filtrele nu există în Minimal APIs; acolo ai endpoint filters (AddEndpointFilter), cu un model mai simplu, tip middleware.

Ce urmărește intervievatorul: Verifică dacă înțelegi modelul de imbricare și unde e locul fiecărui filtru. Greșeala tipică: a pune într-un action filter cod care ar trebui să ruleze înainte de model binding.

67 Mid

Ai un filtru de acțiune care are nevoie de IRepositoryClienti (scoped). De ce nu poți scrie pur și simplu [VerificaClient] și care e diferența între [ServiceFilter] și [TypeFilter]?

Răspuns scurt: Argumentele unui atribut C# trebuie să fie constante, deci un atribut nu primește servicii prin constructor. [ServiceFilter(typeof(F))] cere filtrul din DI (trebuie înregistrat), iar [TypeFilter(typeof(F))] îl creează cu ActivatorUtilities, fără înregistrare, și acceptă argumente suplimentare.

Atributele sunt metadate create de runtime prin reflection; constructorul lor primește doar constante, typeof și tablouri. Un filtru care are nevoie de servicii are trei soluții:

C#
public class VerificaClient(IRepositoryClienti repo) : IAsyncActionFilter
{
    public async Task OnActionExecutionAsync(ActionExecutingContext ctx, ActionExecutionDelegate next)
    {
        if (ctx.ActionArguments.TryGetValue("clientId", out var id)
            && !await repo.ExistaAsync((int)id!))
        {
            ctx.Result = new NotFoundObjectResult($"Clientul {id} nu există");
            return; // nu chemăm next: acțiunea nu rulează
        }
        await next();
    }
}

builder.Services.AddScoped<VerificaClient>();

[HttpGet("{clientId:int}/comenzi")]
[ServiceFilter(typeof(VerificaClient))]
public IActionResult Comenzi(int clientId) => Ok();
  • ServiceFilter rezolvă filtrul din containerul cererii: îi controlezi durata de viață prin înregistrare; dacă uiți AddScoped, primești o excepție la prima cerere.
  • TypeFilter creează o instanță nouă la fiecare utilizare, cu dependențele din DI, și acceptă Arguments = new object[] { "admin" } pentru parametrii care nu sunt servicii. Nu trebuie înregistrat.
  • A treia variantă: un atribut care implementează IFilterFactory și își creează singur filtrul (IsReusable spune dacă instanța poate fi refolosită).

Atenție la IsReusable = true sau la filtrele globale adăugate ca instanță (o.Filters.Add(new F(...))): devin practic singleton și nu au voie să țină servicii scoped.

Ce urmărește intervievatorul: Verifică dacă înțelegi legătura dintre atribute și DI. Mulți candidați încearcă [VerificaClient(repo)] sau rezolvă serviciul cu service locator în filtru.

68 Mid

Echipa de frontend vrea ca toate erorile de validare să vină în formatul { "cod": "VALIDARE", "campuri": [{ "camp": "...", "mesaj": "..." }] }, nu ca ValidationProblemDetails. Cum schimbi răspunsul automat al lui [ApiController]?

Răspuns scurt: Configurezi InvalidModelStateResponseFactory în ConfigureApiBehaviorOptions: primește ActionContext, citești ModelState și întorci propriul IActionResult, de exemplu un BadRequestObjectResult cu formatul cerut. Se aplică tuturor controllerelor.

Răspunsul 400 automat este produs de o fabrică configurabilă. O înlocuiești o dată, la pornire:

C#
builder.Services.AddControllers()
    .ConfigureApiBehaviorOptions(o =>
    {
        o.InvalidModelStateResponseFactory = ctx =>
        {
            var campuri = ctx.ModelState
                .Where(e => e.Value!.Errors.Count > 0)
                .SelectMany(e => e.Value!.Errors.Select(err => new
                {
                    camp = e.Key,
                    mesaj = string.IsNullOrEmpty(err.ErrorMessage)
                        ? "Valoare invalidă." : err.ErrorMessage
                }));
            return new BadRequestObjectResult(new { cod = "VALIDARE", campuri })
            {
                ContentTypes = { "application/json" }
            };
        };
    });

Lucruri de discutat la interviu:

  • Fabrica rulează pentru orice ModelState invalid: atribute de validare, IValidatableObject, dar și erori de binding (JSON invalid, tip greșit); de aceea tratezi ErrorMessage gol, caz în care informația e în Exception.
  • Cheile din ModelState pot fi $.pret pentru erori de JSON sau date.Pret cu prefix; normalizează-le dacă frontend-ul le mapează pe câmpuri.
  • Alternativa „mai standard” este să păstrezi ProblemDetails și să adaugi extensii (CustomizeProblemDetails), ca să rămâi compatibil cu RFC 9457. Un format propriu e o decizie de contract: documenteaz-o în OpenAPI și aplic-o și la Minimal APIs, altfel clienții primesc două formate.
  • SuppressModelStateInvalidFilter = true oprește complet răspunsul automat, dacă vrei să validezi manual în fiecare acțiune; rareori e o idee bună.

Ce urmărește intervievatorul: Verifică dacă știi punctul de extensie corect și dacă te gândești la consistența contractului. Candidații slabi propun un if (!ModelState.IsValid) în fiecare acțiune.

Eroarea, în practică:One or more validation errors occurred. (400)

69 Senior

Cum ai introduce versiunea 2 a unui API cu controllere, în care GET api/comenzi/{id} întoarce un alt format, fără să strici clienții existenți? Ce variante de versionare există?

Răspuns scurt: Variantele sunt: în URL (/api/v2/comenzi), în query (?api-version=2.0), în antet (X-Api-Version) sau în media type. Cu pachetul Asp.Versioning.Mvc declari versiunile pe controllere, păstrezi v1 activ, marchezi v1 ca deprecated și anunți clienții înainte să o retragi.

Versionarea e o decizie de contract, nu doar tehnică. Variantele:

  • Segment în URL: /api/v2/comenzi/7. Cea mai vizibilă, ușor de rutat în gateway și de testat din browser; dezavantaj: aceeași resursă are mai multe URL-uri.
  • Query string: ?api-version=2.0. Simplu, dar ușor de uitat de clienți.
  • Antet: X-Api-Version: 2.0. URL-uri curate, dar mai greu de testat și de pus în cache.
  • Media type: Accept: application/vnd.magazin.v2+json. Cea mai „REST”, cea mai greu de folosit.

Cu Asp.Versioning.Mvc:

C#
builder.Services.AddApiVersioning(o =>
{
    o.DefaultApiVersion = new ApiVersion(1, 0);
    o.AssumeDefaultVersionWhenUnspecified = true;
    o.ReportApiVersions = true; // antetele api-supported-versions / api-deprecated-versions
}).AddMvc();

[ApiController]
[ApiVersion("1.0", Deprecated = true)]
[ApiVersion("2.0")]
[Route("api/v{version:apiVersion}/comenzi")]
public class ComenziController : ControllerBase
{
    [HttpGet("{id:int}"), MapToApiVersion("1.0")]
    public ActionResult<ComandaV1> GetV1(int id) => ...;

    [HttpGet("{id:int}"), MapToApiVersion("2.0")]
    public ActionResult<ComandaV2> GetV2(int id) => ...;
}

La nivel senior contează mai ales procesul: o versiune nouă apare doar pentru schimbări incompatibile (adăugarea unui câmp nu cere v2), logica de domeniu rămâne una singură și doar DTO-urile diferă, măsori cine mai apelează v1 și comunici o dată de retragere (antetele Deprecation și Sunset). Fiecare versiune are propriul document OpenAPI.

Ce urmărește intervievatorul: La senior se urmărește judecata: când merită o versiune nouă și cum o retragi pe cea veche. Răspunsul „pun v2 în URL” fără strategie de retragere este incomplet.

70 Senior

Aplicația mobilă reîncearcă automat POST api/plati când conexiunea cade, iar unii clienți au fost taxați de două ori. Cum faci endpoint-ul idempotent în ASP.NET Core?

Răspuns scurt: Clientul trimite un antet Idempotency-Key unic per operație. Serverul salvează cheia împreună cu răspunsul; la o cerere repetată cu aceeași cheie întoarce răspunsul salvat fără să mai execute plata. Rezervarea cheii trebuie să fie atomică, de exemplu cu un index unic.

POST nu este idempotent prin definiție, dar rețeaua garantează că vor exista reîncercări. Modelul folosit de procesatorii de plăți:

1. Clientul generează un GUID per intenție de plată și îl trimite în Idempotency-Key la fiecare reîncercare. 2. Serverul încearcă să insereze cheia într-un tabel cu index unic (cheie, utilizator), cu starea „în curs”. Dacă inserarea eșuează pe index, cererea e o repetare. 3. La repetare: dacă prima cerere s-a terminat, întorci același status și corp salvate; dacă e încă în curs, răspunzi 409 și clientul reîncearcă mai târziu. 4. Dacă prima cerere s-a terminat, salvezi statusul și corpul răspunsului lângă cheie, cu un termen de expirare (de exemplu 24 de ore).

În ASP.NET Core, logica se pune într-un filtru reutilizabil, ca acțiunile să rămână curate:

C#
public class Idempotent(IMagazieChei chei) : IAsyncActionFilter
{
    public async Task OnActionExecutionAsync(ActionExecutingContext ctx, ActionExecutionDelegate next)
    {
        var cheie = ctx.HttpContext.Request.Headers["Idempotency-Key"].ToString();
        if (string.IsNullOrEmpty(cheie)) { ctx.Result = new BadRequestResult(); return; }

        var salvat = await chei.RezervaSauCitesteAsync(cheie);
        if (salvat is not null) { ctx.Result = salvat.CaRezultat(); return; }

        var executat = await next();
        await chei.SalveazaAsync(cheie, executat.Result);
    }
}

Puncte senior: verifici că aceeași cheie vine cu același corp (altfel 422), rezervarea trebuie să fie atomică (index unic sau SETNX în Redis, nu „citesc apoi scriu”), iar efectul extern (procesatorul) primește și el cheia, ca să fie idempotent cap la cap.

Ce urmărește intervievatorul: Întrebarea verifică gândirea despre sisteme distribuite și condiții de cursă. Răspunsul slab este „verific în bază dacă plata există”, fără atomicitate.

Entity Framework Core în ASP.NET Core

71 Junior

De ce AddDbContext înregistrează contextul ca scoped? Ce s-ar întâmpla dacă l-ai înregistra singleton într-un API?

Răspuns scurt: DbContext este o unitate de lucru, nu e thread-safe și ține în memorie entitățile urmărite, deci scoped înseamnă un context per cerere. Ca singleton, ar fi folosit de cereri concurente, ar crește continuu în memorie și ar întoarce date vechi.

Un DbContext combină trei lucruri: o conexiune (deschisă la nevoie), un change tracker cu toate entitățile încărcate și o tranzacție implicită la SaveChanges. Este gândit pentru o operație scurtă: încarci, modifici, salvezi, arunci.

Durata scoped din ASP.NET Core se potrivește perfect: fiecare cerere primește contextul ei, iar la sfârșitul cererii scope-ul îl eliberează (Dispose) și conexiunea revine în pool.

Ca singleton (AddDbContext<AppDb>(..., ServiceLifetime.Singleton) sau un context ținut într-un câmp static):

  • două cereri simultane folosesc același context și primești InvalidOperationException: A second operation was started on this context instance before a previous operation completed, sau, mai rău, stare coruptă;
  • change tracker-ul nu se golește niciodată: fiecare entitate încărcată rămâne în memorie, iar SaveChanges devine tot mai lent;
  • identity map-ul întoarce instanța deja urmărită, deci o cerere poate vedea date vechi chiar dacă baza s-a schimbat;
  • o eroare de salvare lasă entități în starea Modified care vor fi salvate de cererea următoare, a altui utilizator.
C#
builder.Services.AddDbContext<AppDb>(o =>
    o.UseSqlServer(builder.Configuration.GetConnectionString("Magazin")));

Din același motiv, un serviciu singleton nu are voie să primească AppDb în constructor. Dacă ai nevoie de context în cod de durată lungă (un BackgroundService), creezi un scope sau folosești IDbContextFactory<AppDb>.

Ce urmărește intervievatorul: Verifică dacă înțelegi natura de unitate de lucru a contextului. Candidații slabi spun doar „așa e implicit”, fără consecințele concrete.

Eroarea, în practică:Unable to resolve DbContextOptions<AppDb>Cannot access a disposed context instance

72 Junior

Care este diferența dintre db.Produse.Find(5), db.Produse.FirstOrDefault(p => p.Id == 5) și db.Produse.SingleOrDefault(p => p.Id == 5)? Câte interogări SQL rulează codul de mai jos?

C#
var a = db.Produse.Find(5);
var b = db.Produse.Find(5);
var c = db.Produse.FirstOrDefault(p => p.Id == 5);

Răspuns scurt: Find caută întâi în change tracker după cheia primară și interoghează baza doar dacă entitatea nu e urmărită. FirstOrDefault și SingleOrDefault trimit mereu o interogare. Codul rulează două interogări: prima Find și FirstOrDefault; a doua Find vine din memorie.

Find este specializat pe cheia primară. Pașii lui: caută în identity map-ul contextului o entitate de acel tip cu cheia dată; dacă o găsește, o întoarce fără drum la bază; altfel rulează SELECT ... WHERE Id = @p și începe să o urmărească. Primește și chei compuse (Find(comandaId, produsId)), în ordinea definită în model.

FirstOrDefault(p => p.Id == 5) este o interogare LINQ obișnuită: se traduce mereu în SQL (SELECT TOP(1) ...). Dacă entitatea era deja urmărită, EF întoarce tot instanța din tracker (identity resolution), dar interogarea a rulat oricum. SingleOrDefault cere TOP(2) ca să poată arunca excepție dacă există mai multe rânduri.

În exemplu: a rulează interogarea, b este aceeași instanță, din memorie, fără SQL (ReferenceEquals(a, b) e true), c rulează din nou SQL, dar întoarce aceeași instanță.

Când alegi:

  • Find/FindAsync pentru încărcare după cheie, mai ales în operații de update unde entitatea poate fi deja urmărită.
  • FirstOrDefault când filtrezi după altceva, când ai nevoie de Include, AsNoTracking sau o proiecție (Find nu le acceptă).
  • SingleOrDefault când unicitatea este o regulă și vrei să afli dacă e încălcată.

Atenție: Find vede și entitățile adăugate, dar nesalvate încă (starea Added), ceea ce o interogare nu face.

Ce urmărește intervievatorul: Verifică dacă știi ce face identity map-ul și cum influențează numărul de interogări. Mulți candidați cred că Find e doar un alias.

Eroarea, în practică:Sequence contains no elements (First în EF Core)Composite key: wrong number of values passed to Find

73 Junior

Ce coloane actualizează fiecare variantă de PUT și ce problemă are prima?

C#
// Varianta A
app.MapPut("/produse/{id:int}", async (int id, Produs date, AppDb db) =>
{
    date.Id = id;
    db.Produse.Update(date);
    await db.SaveChangesAsync();
    return Results.NoContent();
});

// Varianta B
app.MapPut("/produse/{id:int}", async (int id, ProdusDto date, AppDb db) =>
{
    var produs = await db.Produse.FindAsync(id);
    if (produs is null) return Results.NotFound();
    produs.Nume = date.Nume;
    produs.Pret = date.Pret;
    await db.SaveChangesAsync();
    return Results.NoContent();
});

Răspuns scurt: Update marchează toate proprietățile ca modificate, deci A scrie toate coloanele cu ce a trimis clientul: câmpurile lipsă devin null sau 0, iar clientul poate modifica și câmpuri interzise. B încarcă entitatea, schimbă doar două câmpuri și generează un UPDATE doar pentru coloanele schimbate.

DbSet.Update(entitate) atașează obiectul cu starea Modified și marchează fiecare proprietate ca modificată, fără să știe ce era în bază. SaveChanges generează UPDATE Produse SET Nume=@p0, Pret=@p1, Stoc=@p2, DataCrearii=@p3, ... WHERE Id=@p9. Probleme în varianta A:

  • un client care trimite doar {"nume":"Mouse","pret":99} resetează Stoc la 0 și DataCrearii la valoarea implicită;
  • clientul poate trimite câmpuri pe care n-ar trebui să le poată schimba (over-posting): "esteAprobat": true;
  • dacă id-ul nu există, primești DbUpdateConcurrencyException (0 rânduri afectate), nu un 404 curat;
  • Update urmărește și navigările din graf, deci un obiect imbricat în corp poate fi inserat sau actualizat.

Varianta B este modelul obișnuit: încarci entitatea urmărită, copiezi doar câmpurile permise din DTO, iar change tracker-ul compară valorile la SaveChanges și scrie doar coloanele realmente schimbate. Dacă valorile trimise sunt identice cu cele din bază, nu rulează niciun UPDATE. Ai și locul natural pentru 404 și pentru verificări de business.

Costul lui B este o interogare în plus. Când ai nevoie de performanță la actualizări în masă fără încărcare, folosești ExecuteUpdateAsync (EF Core 7+), conștient că ocolește change tracker-ul. Update rămâne util pentru scenarii deconectate controlate, cu DTO mapat complet.

Ce urmărește intervievatorul: Verifică dacă știi ce SQL generează Update și riscul de over-posting. Este o greșeală foarte des întâlnită în proiectele junior.

Eroarea, în practică:The instance of entity type cannot be tracked

74 Junior

De ce aruncă endpoint-ul de mai jos The instance of entity type 'Produs' cannot be tracked because another instance with the same key value for {'Id'} is already being tracked? Cum îl repari?

C#
app.MapPut("/produse/{id:int}", async (int id, Produs date, AppDb db) =>
{
    var existent = await db.Produse.FindAsync(id);
    if (existent is null) return Results.NotFound();
    if (existent.Blocat) return Results.Conflict();

    date.Id = id;
    db.Produse.Update(date);
    await db.SaveChangesAsync();
    return Results.NoContent();
});

Răspuns scurt: FindAsync a început să urmărească instanța existent cu Id = id. Update(date) încearcă să urmărească a doua instanță, cu aceeași cheie, iar identity map-ul permite o singură instanță per cheie. Repari copiind valorile în entitatea urmărită: db.Entry(existent).CurrentValues.SetValues(date).

Change tracker-ul garantează că, într-un context, fiecare rând din bază corespunde unei singure instanțe în memorie. Când încerci să atașezi (prin Update, Attach, Add, Remove) un alt obiect cu aceeași cheie, EF nu poate decide care e „adevărat” și aruncă InvalidOperationException.

Variante de reparare:

C#
var existent = await db.Produse.FindAsync(id);
if (existent is null) return Results.NotFound();
if (existent.Blocat) return Results.Conflict();

date.Id = id; // altfel SetValues ar încerca să schimbe cheia
db.Entry(existent).CurrentValues.SetValues(date); // copiază proprietățile scalare
await db.SaveChangesAsync();

SetValues compară valorile și marchează modificate doar proprietățile schimbate. Atenție: copiază toate proprietățile scalare cu același nume, deci primește de preferință un DTO cu doar câmpurile permise.

Alternative:

  • verificarea se face cu o interogare fără urmărire: await db.Produse.AsNoTracking().AnyAsync(p => p.Id == id && !p.Blocat), apoi Update(date);
  • db.ChangeTracker.Clear() înainte de Update (rezolvă eroarea, dar ascunde designul confuz).

Aceeași eroare apare des în teste sau în seed-uri, când adaugi două obiecte noi cu același Id scris de mână, și în relații, când două obiecte imbricate din JSON reprezintă aceeași entitate (de exemplu aceeași categorie, deserializată de două ori). Mesajul sugerează EnableSensitiveDataLogging ca să vezi valoarea cheii: activează-l doar în Development.

Ce urmărește intervievatorul: Este una dintre cele mai căutate erori EF Core. Intervievatorul verifică dacă înțelegi identity map-ul, nu doar dacă știi un workaround.

Eroarea, în practică:The instance of entity type cannot be tracked

75 Junior

O categorie are mai multe produse. Ce se întâmplă la db.Categorii.Remove(categorie); db.SaveChanges(); în funcție de cum e configurată relația? Ce înseamnă DeleteBehavior.Cascade, Restrict și SetNull?

Răspuns scurt: Cu Cascade (implicit pentru relațiile obligatorii) produsele sunt șterse odată cu categoria. Cu SetNull (implicit pentru cele opționale, urmărite) cheia străină devine null. Cu Restrict/NoAction, ștergerea e refuzată dacă există produse: EF aruncă dacă sunt urmărite, altfel baza respinge cu eroare de cheie străină.

Comportamentul depinde de două lucruri: dacă cheia străină e obligatorie (int CategorieId) sau opțională (int? CategorieId), și ce OnDelete ai configurat.

C#
modelBuilder.Entity<Produs>()
    .HasOne(p => p.Categorie)
    .WithMany(c => c.Produse)
    .HasForeignKey(p => p.CategorieId)
    .OnDelete(DeleteBehavior.Restrict);
  • Cascade (implicit la FK obligatoriu): EF marchează ca Deleted produsele urmărite, iar migrarea creează ON DELETE CASCADE, deci și cele neîncărcate sunt șterse de bază.
  • ClientSetNull (implicit la FK opțional): produsele urmărite primesc CategorieId = null; în bază constrângerea e NO ACTION, deci produsele neîncărcate blochează ștergerea.
  • SetNull: la fel, dar și baza pune NULL (ON DELETE SET NULL).
  • Restrict / NoAction: dacă există produse urmărite, EF aruncă InvalidOperationException (relația ar fi ruptă); dacă nu sunt încărcate, baza refuză și primești DbUpdateException cu eroarea de cheie străină (de exemplu The DELETE statement conflicted with the REFERENCE constraint pe SQL Server).

Decizia e de business, nu tehnică: ștergerea unei categorii nu ar trebui să șteargă istoricul comenzilor. Pentru date importante, Restrict plus un mesaj clar (409 „categoria are produse”) sau soft delete sunt mai sigure decât cascada. SQL Server refuză și cascadele pe mai multe căi spre același tabel („may cause cycles or multiple cascade paths”), caz în care alegi Restrict pe una dintre relații.

Ce urmărește intervievatorul: Verifică dacă știi diferența între comportamentul EF pentru entitățile urmărite și constrângerea din bază. Mulți descoperă cascada abia după ce au șters date în producție.

Eroarea, în practică:The association between entities has been severed

76 Mid

În producție apare intermitent InvalidOperationException: A second operation was started on this context instance before a previous operation completed. Codul suspect este mai jos. Cum ai investiga și cum repari?

C#
app.MapGet("/tablou", async (AppDb db) =>
{
    var comenzi = db.Comenzi.CountAsync();
    var clienti = db.Clienti.CountAsync();
    var produse = db.Produse.CountAsync();
    await Task.WhenAll(comenzi, clienti, produse);
    return new { comenzi = comenzi.Result, clienti = clienti.Result, produse = produse.Result };
});

Răspuns scurt: Un DbContext permite o singură operație asincronă odată. Task.WhenAll pornește trei interogări pe același context în paralel. Repari cu await succesiv sau, dacă paralelismul chiar contează, cu un context separat pentru fiecare interogare, din IDbContextFactory.

Pașii de investigare, ca model de răspuns:

  • Citesc stack trace-ul complet din loguri: el arată endpoint-ul și linia unde a pornit a doua operație.
  • Caut tiparele clasice: Task.WhenAll sau Parallel.ForEach peste același context, un async void, un await uitat (operația continuă în fundal), un context partajat de un singleton sau un câmp static, un foreach peste o interogare deschisă în care se rulează altă interogare.
  • Explic de ce e intermitent: dacă o interogare se termină foarte repede, a doua apucă să pornească după ea; sub încărcare, ele se suprapun.

Aici cauza e evidentă: cele trei CountAsync rulează simultan pe aceeași conexiune și același change tracker, iar EF detectează folosirea concurentă și aruncă.

Repararea simplă, suficientă de obicei:

C#
app.MapGet("/tablou", async (AppDb db) => new
{
    comenzi = await db.Comenzi.CountAsync(),
    clienti = await db.Clienti.CountAsync(),
    produse = await db.Produse.CountAsync()
});

Dacă măsurătorile arată că paralelismul aduce un câștig real, fiecare interogare primește contextul ei:

C#
app.MapGet("/tablou", async (IDbContextFactory<AppDb> f) =>
{
    async Task<int> Numara<T>(Func<AppDb, IQueryable<T>> q)
    { await using var db = await f.CreateDbContextAsync(); return await q(db).CountAsync(); }
    var r = await Task.WhenAll(Numara(d => d.Comenzi), Numara(d => d.Clienti), Numara(d => d.Produse));
    return new { comenzi = r[0], clienti = r[1], produse = r[2] };
});

Pentru prevenire: o regulă de code review „niciun WhenAll peste același context” și un test de încărcare pe endpoint-urile agregate.

Ce urmărește intervievatorul: Verifică dacă știi că DbContext nu este thread-safe și dacă ai o metodă de depanare. Răspunsul ideal pornește de la stack trace, nu de la ghicit.

Eroarea, în practică:A second operation was started on this context

77 Mid

Ce SQL generează EF Core pentru interogarea de mai jos și ce problemă de performanță poate apărea? Ce fac filtered include și AsSplitQuery()?

C#
var clienti = await db.Clienti
    .Include(c => c.Comenzi.Where(o => o.Status == Status.Livrata).OrderByDescending(o => o.Data).Take(5))
    .Include(c => c.Adrese)
    .ToListAsync();

Răspuns scurt: Implicit, EF face o singură interogare cu LEFT JOIN pe ambele colecții, iar rândurile se înmulțesc (comenzi × adrese per client): „cartesian explosion”. Filtered include (EF Core 5+) încarcă doar comenzile filtrate. AsSplitQuery() trimite câte o interogare per colecție și evită înmulțirea rândurilor.

Cu două colecții incluse în aceeași interogare, rezultatul SQL conține pentru fiecare client produsul cartezian între comenzile și adresele lui: 5 comenzi și 4 adrese înseamnă 20 de rânduri, fiecare repetând coloanele clientului. Pe date reale, traficul și timpul cresc exponențial. EF Core afișează chiar un avertisment despre interogarea care încarcă mai multe colecții fără configurarea comportamentului de split.

Filtered include permite Where, OrderBy, Skip, Take în interiorul lui Include. Aici se încarcă doar ultimele 5 comenzi livrate ale fiecărui client, iar colecția Comenzi din entitate conține doar acelea. Atenție: dacă aceleași comenzi au fost deja urmărite de context printr-o altă interogare, colecția poate conține mai multe (fix-up-ul adaugă tot ce e urmărit).

Split queries:

C#
var clienti = await db.Clienti
    .Include(c => c.Comenzi.Where(o => o.Status == Status.Livrata))
    .Include(c => c.Adrese)
    .AsSplitQuery()
    .ToListAsync();

EF trimite trei interogări: clienții, comenzile (cu JOIN spre clienți) și adresele. Avantaje: fără rânduri duplicate. Dezavantaje: mai multe drumuri la bază și lipsa unei vederi consistente dacă datele se schimbă între interogări (folosește o tranzacție dacă e important). Poți seta comportamentul global cu o.UseSqlServer(cs, x => x.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery)) și reveni punctual cu AsSingleQuery().

Regula practică: o colecție inclusă, single query; mai multe colecții mari, split query; iar pentru ecrane de listă, o proiecție cu Select e de obicei mai bună decât oricare.

Ce urmărește intervievatorul: Verifică dacă știi ce SQL produce Include, nu doar sintaxa. Problema cartesian explosion apare des la endpoint-uri care „merg local, dar sunt lente în producție”.

Eroarea, în practică:NullReferenceException pe navigare fără Include

78 Mid

Ce fac ExecuteUpdateAsync și ExecuteDeleteAsync (EF Core 7+)? Ce afișează codul de mai jos și ce ocolesc aceste metode?

C#
var p = await db.Produse.FindAsync(1);          // Pret = 100
await db.Produse.Where(x => x.Id == 1)
    .ExecuteUpdateAsync(s => s.SetProperty(x => x.Pret, x => x.Pret * 1.1m));
Console.WriteLine(p!.Pret);

Răspuns scurt: Trimit direct în bază un singur UPDATE sau DELETE cu WHERE, fără să încarce entitățile. Codul afișează 100: entitatea urmărită nu este actualizată. Ele ocolesc change tracker-ul, SaveChanges, interceptorii de salvare, cascadele făcute de EF și verificarea automată a token-urilor de concurență.

Înainte de EF Core 7, ca să scumpești toate produsele dintr-o categorie trebuia să le încarci, să le modifici în buclă și să chemi SaveChanges, care trimitea câte un UPDATE per rând. Acum:

C#
int randuri = await db.Produse
    .Where(p => p.CategorieId == 3)
    .ExecuteUpdateAsync(s => s
        .SetProperty(p => p.Pret, p => p.Pret * 1.1m)
        .SetProperty(p => p.ModificatLa, DateTime.UtcNow));

await db.Sesiuni.Where(s => s.Expira < acum).ExecuteDeleteAsync();

Fiecare apel este o singură comandă SQL, executată imediat (nu la SaveChanges), și întoarce numărul de rânduri afectate.

Ce trebuie să știi înainte să le folosești:

  • Change tracker-ul nu află nimic: entitățile deja încărcate păstrează valorile vechi, de aceea exemplul afișează 100. Dacă ai nevoie de valorile noi, reîncarci (Entry(p).ReloadAsync()) sau nu amesteci cele două stiluri în același context.
  • Nu rulează logica din SaveChanges: câmpuri de audit completate într-un override al lui SaveChanges, interceptori SaveChangesInterceptor, evenimente de domeniu.
  • Cascadele se fac doar de baza de date (ON DELETE CASCADE), nu de EF.
  • Concurența optimistă nu se verifică automat: adaugi tu condiția pe RowVersion în Where.
  • Global query filters se aplică (poți folosi IgnoreQueryFilters()).
  • Providerul InMemory nu le suportă, deci testele cu InMemory pică; testează cu SQLite sau cu baza reală.

Sunt alegerea bună pentru operații în masă și joburi de curățenie, nu pentru logica obișnuită a unei cereri.

Ce urmărește intervievatorul: Verifică dacă știi funcționalitățile moderne și, mai ales, compromisurile lor. Candidații care le recomandă peste tot uită de audit și de entitățile urmărite.

79 Mid

Cum implementezi soft delete cu global query filters în EF Core? Ce capcane are această abordare?

Răspuns scurt: Adaugi EsteSters pe entitate, configurezi HasQueryFilter(p => !p.EsteSters), iar ștergerea devine EsteSters = true (de exemplu într-un interceptor). Capcane: filtrul se aplică peste tot, inclusiv la Include și relații obligatorii, indexurile unice trebuie filtrate, iar IgnoreQueryFilters() le dezactivează pe toate.

Un global query filter este un predicat adăugat automat la orice interogare pe acel tip de entitate:

C#
public class AppDb(DbContextOptions<AppDb> o) : DbContext(o)
{
    public DbSet<Produs> Produse => Set<Produs>();

    protected override void OnModelCreating(ModelBuilder b)
    {
        b.Entity<Produs>().HasQueryFilter(p => !p.EsteSters);
        b.Entity<Produs>().HasIndex(p => p.Cod).IsUnique().HasFilter("[EsteSters] = 0");
    }

    public override Task<int> SaveChangesAsync(CancellationToken ct = default)
    {
        foreach (var e in ChangeTracker.Entries<Produs>().Where(e => e.State == EntityState.Deleted))
        {
            e.State = EntityState.Modified;
            e.Entity.EsteSters = true;
        }
        return base.SaveChangesAsync(ct);
    }
}

Codul aplicației rămâne db.Produse.Remove(p), iar db.Produse.ToList() nu mai vede produsele șterse.

Capcanele pe care le discuți:

  • Relații obligatorii: dacă o comandă are produsul șters, Include(c => c.Produs) poate da o navigare null deși FK-ul e obligatoriu; EF avertizează la construirea modelului.
  • Unicitate: un cod de produs șters blochează reutilizarea codului; de aceea indexul filtrat.
  • IgnoreQueryFilters() dezactivează toate filtrele entității (în EF Core 10 apar filtre cu nume, dezactivabile individual); dacă folosești același mecanism și pentru multi-tenant, un ecran de admin care vrea să vadă șterse riscă să vadă și datele altor clienți.
  • ExecuteDelete și SQL-ul brut ocolesc conversia ștergerii; cascadele din bază nu știu de soft delete.
  • Performanța: adaugi EsteSters în indexurile folosite des.

Pentru multi-tenant, filtrul folosește un câmp al contextului (p.TenantId == _tenantId), evaluat per instanță de context, nu o constantă.

Ce urmărește intervievatorul: Întrebarea verifică dacă ai folosit filtrele în aplicații reale și le cunoști efectele secundare. Răspunsul care spune doar „pun HasQueryFilter” e incomplet.

80 Senior

Ai un BackgroundService care procesează comenzile din coadă și un endpoint foarte solicitat. Când folosești IServiceScopeFactory, IDbContextFactory<T> și AddDbContextPool? Ce restricții are pooling-ul?

Răspuns scurt: În BackgroundService (singleton) creezi un scope per unitate de lucru sau un context din IDbContextFactory. AddDbContextPool refolosește instanțe de context între cereri ca să reducă costul creării lor; restricția este că contextul nu are voie să aibă stare proprie per cerere, injectată în constructor.

Un BackgroundService este înregistrat singleton și trăiește cât aplicația. Un DbContext injectat direct ar fi captiv și ar crește la nesfârșit. Două variante corecte:

C#
public class ProcesorComenzi(IDbContextFactory<AppDb> fabrica, ILogger<ProcesorComenzi> log)
    : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stop)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(10));
        while (await timer.WaitForNextTickAsync(stop))
        {
            await using var db = await fabrica.CreateDbContextAsync(stop);
            var noi = await db.Comenzi.Where(c => c.Status == Status.Noua).Take(50).ToListAsync(stop);
            foreach (var c in noi) c.Status = Status.InLucru;
            await db.SaveChangesAsync(stop);
        }
    }
}
  • IServiceScopeFactory.CreateScope() e potrivit când unitatea de lucru are nevoie de mai multe servicii scoped (repository, servicii de domeniu care primesc contextul); toate primesc aceeași instanță din scope.
  • IDbContextFactory<T> (cu AddDbContextFactory sau AddPooledDbContextFactory) e potrivit când ai nevoie doar de contexte de scurtă durată sau de mai multe în paralel, de exemplu în Blazor Server, unde un circuit trăiește mult.

Pooling-ul (AddDbContextPool<AppDb>(..., poolSize: 1024)) păstrează contextele eliberate și le resetează pentru următoarea cerere, economisind alocarea și inițializarea serviciilor interne. Câștigul se vede doar la încărcări foarte mari; măsoară înainte. Restricții: constructorul primește doar DbContextOptions, nu servicii scoped (un ITenant din cererea curentă ar rămâne de la cererea anterioară), OnConfiguring nu poate depinde de cerere, iar câmpurile proprii trebuie resetate manual. Starea per cerere se setează după obținerea contextului, nu în constructor.

Ce urmărește intervievatorul: La senior se verifică înțelegerea duratelor de viață în cod de lungă durată și a compromisurilor de performanță. Greșeala tipică: pooling activat pe un context care primește tenantul în constructor.

Eroarea, în practică:Cannot access a disposed context instance

Autentificare, autorizare și securitate

Exersează capitolul cu exerciții reale: Curs ASP.NET Core online →
81 Junior

Explică fiecare proprietate din configurarea de mai jos. Ce se întâmplă dacă lipsește ValidAudience?

C#
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(o =>
    {
        o.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidIssuer = "https://auth.magazin.ro",
            ValidateAudience = true,
            ValidAudience = "api-comenzi",
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(cheie)),
            ClockSkew = TimeSpan.FromSeconds(30)
        };
    });

Răspuns scurt: Middleware-ul verifică semnătura cu cheia, emitentul (iss), destinatarul (aud), expirarea și nbf, cu toleranța ClockSkew. Dacă ValidateAudience e true și nu dai niciun ValidAudience, orice token este respins cu 401 pentru audience invalid.

Fiecare cerere cu Authorization: Bearer <token> trece prin JwtBearerHandler, care validează tokenul după aceste reguli:

  • Semnătura (ValidateIssuerSigningKey, IssuerSigningKey): tokenul a fost semnat cu cheia așteptată, deci nu a fost modificat. Cu HMAC (HS256), cheia trebuie să aibă cel puțin 256 de biți, altfel primești eroarea IDX10720. Cu RSA/ECDSA de la un furnizor de identitate, setezi o.Authority, iar cheile publice se descarcă automat din documentul OpenID.
  • Emitentul (iss): tokenul vine de la serverul tău de autentificare, nu de la altul care folosește întâmplător aceeași cheie.
  • Destinatarul (aud): tokenul a fost emis pentru acest API. Fără verificare, un token emis pentru alt serviciu al companiei ar fi acceptat și aici.
  • Durata (exp, nbf): tokenul nu e expirat și nu e folosit înainte de vreme.
  • ClockSkew: toleranța pentru ceasuri nesincronizate; implicit 5 minute.

Dacă ValidateAudience = true și nu setezi ValidAudience/ValidAudiences, validarea pică pentru orice token, iar răspunsul e 401 cu WWW-Authenticate: Bearer error="invalid_token", error_description="The audience 'api-comenzi' is invalid". Soluția nu este ValidateAudience = false, ci configurarea audience-ului corect.

Pentru depanare, o.Events = new JwtBearerEvents { OnAuthenticationFailed = ctx => { log...; return Task.CompletedTask; } } arată motivul exact. Cheia nu se scrie în cod: vine din configurare (User Secrets local, un seif de secrete în producție).

Ce urmărește intervievatorul: Verifică dacă înțelegi ce protejează fiecare verificare, nu doar că ai copiat configurarea. Dezactivarea validărilor ca să „meargă” este un semnal rău.

Eroarea, în practică:Bearer invalid_token: The audience is invalidIDX10214: Audience validation failed

82 Junior

Un tester raportează că un token care a expirat acum două minute este încă acceptat de API, iar unul expirat acum zece minute este respins. Este un bug?

Răspuns scurt: Nu, este ClockSkew: JwtBearer acceptă implicit tokenurile până la 5 minute după exp, ca să tolereze ceasurile nesincronizate. Dacă tokenurile au durată scurtă, reduci toleranța, de exemplu ClockSkew = TimeSpan.FromSeconds(30), dar nu la zero fără motiv.

Validarea duratei compară exp (și nbf) din token cu ora serverului, cu o marjă: ClockSkew, implicit TimeSpan.FromMinutes(5). Serverul de autentificare și API-ul rulează pe mașini diferite, iar ceasurile lor pot fi decalate cu câteva secunde sau minute; fără marjă, un token abia emis ar putea fi respins ca „încă nevalid” (nbf în viitor), sau unul valid ar expira prea devreme.

Comportamentul raportat este deci cel documentat:

  • expirat acum 2 minute, în marja de 5: acceptat;
  • expirat acum 10 minute: 401 cu error_description="The token expired at '...'".

Ce poți răspunde testerului și echipei:

C#
o.TokenValidationParameters = new TokenValidationParameters
{
    // ...
    ValidateLifetime = true,
    ClockSkew = TimeSpan.FromSeconds(30)
};
  • Dacă access token-ul trăiește 5–15 minute, o marjă de 5 minute este proporțional mare; 30–60 de secunde sunt de obicei suficiente când serverele folosesc NTP.
  • ClockSkew = TimeSpan.Zero face testele deterministe, dar în producție poate produce 401 intermitente greu de explicat.
  • Expirarea nu înseamnă revocare: un token furat rămâne valid până la exp + marjă. Pentru revocare imediată ai nevoie de tokenuri scurte cu refresh token revocabil, sau de o listă de tokenuri revocate verificată în OnTokenValidated.

Testul bun pentru această regulă folosește un ceas controlat (TimeProvider) sau tokenuri generate cu exp în trecut, nu așteptare reală.

Ce urmărește intervievatorul: Întrebarea verifică dacă știi parametrii impliciți și dacă poți explica un comportament aparent ciudat. Mulți setează ClockSkew la zero fără să înțeleagă riscul.

Eroarea, în practică:Bearer invalid_token: The token expired at

83 Junior

Când răspunde ASP.NET Core cu 401 și când cu 403? Ce primește clientul la fiecare cerere de mai jos?

C#
app.MapGet("/profil", () => "profil").RequireAuthorization();
app.MapGet("/admin", () => "admin").RequireAuthorization(p => p.RequireRole("admin"));

// 1. GET /profil  fără antet Authorization
// 2. GET /admin   cu token valid pentru „ana” (fără roluri)
// 3. GET /admin   cu token semnat cu altă cheie

Răspuns scurt: 401 înseamnă „nu știu cine ești” (challenge): lipsă token sau token invalid. 403 înseamnă „știu cine ești, dar nu ai voie” (forbid). Deci: 1 → 401, 2 → 403, 3 → 401, cu WWW-Authenticate: Bearer error="invalid_token".

Autorizarea evaluează politica endpoint-ului cu utilizatorul produs de autentificare. Rezultatul are trei forme:

  • politica trece: endpoint-ul rulează (200);
  • politica pică și utilizatorul nu e autentificat: middleware-ul cheamă ChallengeAsync pe schema implicită; JwtBearer răspunde 401 cu antetul WWW-Authenticate: Bearer;
  • politica pică, dar utilizatorul e autentificat: se cheamă ForbidAsync, iar răspunsul e 403, de obicei cu corp gol.

În exemplu:

1. Fără antet, utilizatorul e anonim: 401 cu WWW-Authenticate: Bearer. 2. „ana” e autentificată, dar nu are rolul admin: 403. 3. Semnătura nu se verifică, deci autentificarea pică, iar utilizatorul e tratat ca anonim: 401, cu error="invalid_token", error_description="The signature is invalid".

Erori frecvente care strică această logică:

  • UseAuthorization() pus înaintea lui UseAuthentication() sau lipsa lui UseAuthentication() acolo unde îl apelezi explicit: utilizatorul pare mereu anonim, deci totul e 401.
  • O schemă cookie implicită într-un API: challenge-ul devine redirect 302 spre /Account/Login, nu 401; clienții JavaScript primesc HTML.
  • Întoarcerea manuală a lui 401 pentru „nu ai dreptul”: clientul va încerca inutil să se reautentifice. Pentru resurse ale altui utilizator, unele API-uri preferă chiar 404, ca să nu dezvăluie că resursa există.

În cod, Results.Challenge() și Results.Forbid() (sau Challenge()/Forbid() în controllere) produc exact aceste răspunsuri prin handler-ul schemei.

Ce urmărește intervievatorul: Verifică dacă știi diferența semantică și cum o implementează framework-ul. Confuzia 401/403 apare des în API-urile scrise de juniori.

Eroarea, în practică:401 Unauthorized, WWW-Authenticate: BearerNo authenticationScheme / DefaultForbidScheme

84 Junior

Tokenul conține "sub": "42", "unique_name": "ana" și "role": "admin", dar în endpoint User.FindFirst("sub") este null. De ce și cum citești corect identitatea?

Răspuns scurt: JwtBearer mapează implicit numele claim-urilor JWT la tipurile lungi din ClaimTypes: sub devine ClaimTypes.NameIdentifier, unique_name devine ClaimTypes.Name, role devine ClaimTypes.Role. Citești User.FindFirstValue(ClaimTypes.NameIdentifier) sau dezactivezi maparea cu MapInboundClaims = false.

Din motive istorice (compatibilitate cu WS-Federation și cu .NET Framework), handlerul JWT transformă tipurile scurte ale claim-urilor în URI-uri lungi:

  • sub → http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier (ClaimTypes.NameIdentifier)
  • unique_name → ClaimTypes.Name, deci User.Identity.Name este „ana”
  • role → ClaimTypes.Role, folosit de IsInRole și [Authorize(Roles = ...)]
  • email → ClaimTypes.Email

De aceea FindFirst("sub") nu găsește nimic. Două abordări corecte:

C#
// 1. Folosești tipurile mapate
app.MapGet("/eu", (ClaimsPrincipal user) => new
{
    id = user.FindFirstValue(ClaimTypes.NameIdentifier),
    nume = user.Identity?.Name,
    admin = user.IsInRole("admin")
}).RequireAuthorization();

// 2. Păstrezi numele originale și spui ce claim e numele și rolul
.AddJwtBearer(o =>
{
    o.MapInboundClaims = false;
    o.TokenValidationParameters.NameClaimType = "unique_name";
    o.TokenValidationParameters.RoleClaimType = "role";
});

A doua variantă e preferată de multe echipe: claim-urile au aceleași nume ca în token și în documentația furnizorului de identitate. Dacă dezactivezi maparea fără să setezi NameClaimType și RoleClaimType, User.Identity.Name devine null și verificările de rol pică, chiar dacă tokenul conține rolul.

Pentru depanare, un endpoint temporar (doar în Development) care întoarce user.Claims.Select(c => new { c.Type, c.Value }) arată imediat ce a ajuns în aplicație.

Ce urmărește intervievatorul: Întrebarea verifică experiența practică cu JWT în .NET. Aproape oricine a integrat un furnizor de identitate s-a lovit de maparea claim-urilor.

Eroarea, în practică:NullReferenceException la User.FindFirst("sub")

85 Junior

Frontend-ul de pe https://magazin.ro apelează API-ul de pe https://api.magazin.ro. Din Postman merge, din browser apare blocked by CORS policy. De ce, ce este un preflight și cum configurezi CORS în ASP.NET Core?

Răspuns scurt: CORS este o regulă a browserului: o pagină citește răspunsuri de la altă origine doar dacă serverul o permite prin antetele Access-Control-Allow-*; Postman nu o aplică. Pentru cereri „non-simple” browserul trimite întâi un OPTIONS (preflight). Configurezi cu AddCors și UseCors.

Originea este schema + domeniul + portul. https://magazin.ro și https://api.magazin.ro sunt origini diferite, deci un fetch între ele este cross-origin. Serverul primește cererea și răspunde, dar browserul nu dă răspunsul codului JavaScript dacă lipsește Access-Control-Allow-Origin cu originea paginii. Postman, curl sau alt server nu sunt browsere, deci nu verifică nimic.

Pentru cereri care nu sunt „simple” (metode precum PUT/DELETE, Content-Type: application/json, antete precum Authorization), browserul trimite întâi o cerere de verificare:

OPTIONS /api/comenzi
Origin: https://magazin.ro
Access-Control-Request-Method: POST
Access-Control-Request-Headers: authorization, content-type

Dacă răspunsul nu permite metoda și antetele, cererea reală nici nu pleacă.

Configurarea:

C#
builder.Services.AddCors(o => o.AddPolicy("Frontend", p => p
    .WithOrigins("https://magazin.ro")
    .WithMethods("GET", "POST", "PUT", "DELETE")
    .WithHeaders("Authorization", "Content-Type")));

var app = builder.Build();
app.UseCors("Frontend");      // după UseRouting (dacă îl apelezi), înainte de autorizare
app.UseAuthentication();
app.UseAuthorization();

Capcane frecvente: origine scrisă cu / la final (https://magazin.ro/ nu se potrivește), UseCors pus după autorizare (preflight-ul primește 401, pentru că nu are token), sau un 500 pe care browserul îl raportează tot ca eroare CORS, pentru că răspunsul de eroare nu are antetele. Verifică mereu în tab-ul Network ce status a avut cererea reală.

Ce urmărește intervievatorul: Verifică dacă știi că CORS e o protecție a browserului, nu a serverului. Candidații slabi cred că CORS îi protejează API-ul de apeluri neautorizate.

86 Mid

Un coleg a configurat CORS ca mai jos, ca frontend-ul să poată trimite cookie-uri. Aplicația aruncă excepție la pornire sau browserul refuză răspunsul. De ce, și ce propui în loc?

C#
builder.Services.AddCors(o => o.AddDefaultPolicy(p => p
    .AllowAnyOrigin()
    .AllowAnyHeader()
    .AllowAnyMethod()
    .AllowCredentials()));

Răspuns scurt: Specificația CORS interzice Access-Control-Allow-Origin: * împreună cu credențiale, iar ASP.NET Core refuză combinația AllowAnyOrigin + AllowCredentials. Altfel, orice site ar putea face cereri autentificate cu cookie-urile utilizatorului. Listezi explicit originile cu WithOrigins, eventual citite din configurare.

Când browserul trimite credențiale (cookie-uri, autentificare HTTP, certificate client) cross-origin, răspunsul trebuie să conțină originea exactă în Access-Control-Allow-Origin și Access-Control-Allow-Credentials: true. Wildcard-ul * nu este acceptat de browser în acest caz.

Motivul e de securitate: dacă orice origine ar putea trimite cereri cu cookie-ul de sesiune al utilizatorului și ar putea citi răspunsul, un site rău-intenționat ar citi datele contului lui. ASP.NET Core detectează configurarea și aruncă InvalidOperationException: The CORS protocol does not allow specifying a wildcard (any) origin and credentials at the same time.

Varianta greșită pe care unii o găsesc pe internet este SetIsOriginAllowed(_ => true) împreună cu AllowCredentials(): trece de verificare, dar reflectă orice origine, adică exact vulnerabilitatea pe care regula o previne.

Configurarea corectă:

C#
var origini = builder.Configuration.GetSection("Cors:Origini").Get<string[]>() ?? [];

builder.Services.AddCors(o => o.AddPolicy("Frontend", p => p
    .WithOrigins(origini)                 // ex. https://magazin.ro, https://admin.magazin.ro
    .AllowAnyHeader()
    .WithMethods("GET", "POST", "PUT", "DELETE")
    .AllowCredentials()
    .SetPreflightMaxAge(TimeSpan.FromMinutes(10))));

Cookie-urile cross-site mai au nevoie și de SameSite=None; Secure, iar o aplicație cu cookie-uri trebuie protejată și împotriva CSRF (antiforgery), pentru că CORS nu oprește trimiterea cererii, ci doar citirea răspunsului. Dacă API-ul folosește tokenuri Bearer în antet, nu ai nevoie de AllowCredentials deloc.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce există regula, nu doar cum ocolești excepția. SetIsOriginAllowed(_ => true) cu credențiale este un semnal de alarmă.

87 Mid

Scrie o politică de autorizare „Major” care permite accesul doar utilizatorilor cu claim-ul data_nasterii care au cel puțin 18 ani. De ce nu ajunge RequireClaim?

Răspuns scurt: RequireClaim verifică doar existența claim-ului sau valori fixe. O regulă cu calcul se scrie ca o cerință (IAuthorizationRequirement) plus un AuthorizationHandler<T> care citește claim-ul, calculează vârsta și cheamă context.Succeed. Handler-ul se înregistrează în DI, iar politica se aplică cu RequireAuthorization("Major").

O politică este o listă de cerințe care trebuie îndeplinite toate. Pentru reguli simple ai metodele gata făcute (RequireRole, RequireClaim("plan", "pro")), iar pentru restul scrii o cerință cu handler:

C#
public record VarstaMinima(int Ani) : IAuthorizationRequirement;

public class VarstaMinimaHandler(TimeProvider ceas) : AuthorizationHandler<VarstaMinima>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext ctx, VarstaMinima cerinta)
    {
        var text = ctx.User.FindFirst("data_nasterii")?.Value;
        if (DateOnly.TryParse(text, CultureInfo.InvariantCulture, out var nastere))
        {
            var azi = DateOnly.FromDateTime(ceas.GetUtcNow().UtcDateTime);
            var varsta = azi.Year - nastere.Year - (azi < nastere.AddYears(azi.Year - nastere.Year) ? 1 : 0);
            if (varsta >= cerinta.Ani) ctx.Succeed(cerinta);
        }
        return Task.CompletedTask; // fără Succeed => cerința nu e îndeplinită
    }
}

builder.Services.AddSingleton(TimeProvider.System);
builder.Services.AddSingleton<IAuthorizationHandler, VarstaMinimaHandler>();
builder.Services.AddAuthorizationBuilder()
    .AddPolicy("Major", p => p.RequireAuthenticatedUser().AddRequirements(new VarstaMinima(18)));

app.MapPost("/comenzi/alcool", () => "ok").RequireAuthorization("Major");

Detalii de discutat:

  • Un handler care nu cheamă nici Succeed, nici Fail doar se abține; dacă niciun handler nu reușește, autorizarea pică (403 pentru un utilizator autentificat).
  • Fail() oprește politica chiar dacă alt handler ar reuși; folosește-l pentru interdicții explicite.
  • Separarea cerinței (date) de handler (logică) permite mai multe handlere pentru aceeași cerință („major” SAU „are acordul părinților”).
  • Ceasul injectat face handler-ul testabil fără dependență de data curentă.

Ce urmărește intervievatorul: Verifică dacă știi modelul de autorizare bazat pe politici dincolo de roluri. Candidații slabi pun calculul direct în fiecare endpoint.

Eroarea, în practică:The AuthorizationPolicy named: 'X' was not found

88 Mid

Într-un blog, orice utilizator autentificat poate citi articolele, dar doar autorul unui articol (sau un editor) îl poate modifica. De ce nu poți rezolva asta cu [Authorize(Policy = ...)] și cum o rezolvi?

Răspuns scurt: Atributul se evaluează înainte de acțiune, fără să știe ce articol e cerut. Ai nevoie de autorizare pe resursă: încarci articolul, apoi chemi IAuthorizationService.AuthorizeAsync(User, articol, "PoateEdita"), cu un handler AuthorizationHandler<Cerinta, Articol> care compară autorul cu utilizatorul.

Politica din atribut are acces doar la utilizator și la endpoint. Regula „doar autorul” depinde de datele resursei, care se află în bază, deci verificarea se face după încărcare, în cod:

C#
public record PoateEdita : IAuthorizationRequirement;

public class AutorSauEditor : AuthorizationHandler<PoateEdita, Articol>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext ctx,
        PoateEdita cerinta, Articol articol)
    {
        var id = ctx.User.FindFirstValue(ClaimTypes.NameIdentifier);
        if (articol.AutorId == id || ctx.User.IsInRole("editor"))
            ctx.Succeed(cerinta);
        return Task.CompletedTask;
    }
}

builder.Services.AddSingleton<IAuthorizationHandler, AutorSauEditor>();
builder.Services.AddAuthorizationBuilder()
    .AddPolicy("PoateEdita", p => p.AddRequirements(new PoateEdita()));

app.MapPut("/articole/{id:int}", async (int id, ArticolDto date, ClaimsPrincipal user,
    IAuthorizationService auth, AppDb db) =>
{
    var articol = await db.Articole.FindAsync(id);
    if (articol is null) return Results.NotFound();

    var rezultat = await auth.AuthorizeAsync(user, articol, "PoateEdita");
    if (!rezultat.Succeeded) return Results.Forbid();

    articol.Titlu = date.Titlu;
    await db.SaveChangesAsync();
    return Results.NoContent();
}).RequireAuthorization();

De ce e mai bun decât un if în endpoint: regula stă într-un singur loc, se reutilizează la ștergere, la publicare și în interfață („arată butonul Editează?”), și se testează separat. RequireAuthorization() rămâne pentru partea „trebuie să fii autentificat”.

Atenție la ordinea răspunsurilor: unele echipe întorc 404 în loc de 403 pentru resursele altora, ca să nu dezvăluie existența lor. Aceasta e și apărarea împotriva IDOR (Insecure Direct Object Reference), una dintre cele mai frecvente vulnerabilități în API-uri: niciodată să nu te bazezi doar pe faptul că id-ul „nu e ghicit”.

Ce urmărește intervievatorul: Verifică dacă știi autorizarea pe resursă și dacă recunoști riscul IDOR. Mulți candidați protejează endpoint-ul, dar nu și resursa.

89 Senior

Endpoint-ul POST /api/login este atacat prin încercări repetate de parole. Cum folosești rate limiting-ul din ASP.NET Core (.NET 7+) ca să limitezi încercările per adresă IP, și ce alte măsuri ai lua?

Răspuns scurt: Înregistrezi un limiter cu AddRateLimiter, de exemplu o fereastră fixă partiționată după IP, setezi RejectionStatusCode = 429, adaugi app.UseRateLimiter() și pui .RequireRateLimiting("login") pe endpoint. Completezi cu blocare pe cont, întârzieri progresive și monitorizare.

Middleware-ul Microsoft.AspNetCore.RateLimiting oferă algoritmi de tip fixed window, sliding window, token bucket și concurrency, iar partiționarea permite câte un contor per cheie:

C#
builder.Services.AddRateLimiter(o =>
{
    o.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
    o.AddPolicy("login", ctx => RateLimitPartition.GetFixedWindowLimiter(
        partitionKey: ctx.Connection.RemoteIpAddress?.ToString() ?? "necunoscut",
        factory: _ => new FixedWindowRateLimiterOptions
        {
            PermitLimit = 5,
            Window = TimeSpan.FromMinutes(1),
            QueueLimit = 0
        }));
    o.OnRejected = (ctx, ct) =>
    {
        ctx.HttpContext.Response.Headers.RetryAfter = "60";
        return ValueTask.CompletedTask;
    };
});

var app = builder.Build();
app.UseRateLimiter();
app.MapPost("/api/login", Login).RequireRateLimiting("login");

Puncte senior:

  • IP-ul real: în spatele unui load balancer, RemoteIpAddress este al proxy-ului; configurezi UseForwardedHeaders cu proxy-urile de încredere, altfel toți utilizatorii împart aceeași limită sau atacatorul falsifică X-Forwarded-For.
  • Mai multe instanțe: limiter-ul ține contoarele în memorie, per proces. Cu 4 instanțe, limita reală e de 4 ori mai mare; pentru o limită globală folosești un magazin distribuit (Redis) sau limitarea din gateway/WAF.
  • Atacurile distribuite (multe IP-uri, aceeași parolă pe multe conturi) nu sunt oprite de o limită per IP: adaugi limită per cont, blocare temporară după încercări eșuate, CAPTCHA după câteva eșecuri, autentificare în doi pași.
  • Răspunsuri uniforme: același mesaj și timp aproximativ egal pentru „utilizator inexistent” și „parolă greșită”.
  • Alertare pe numărul de 429 și de autentificări eșuate.

Ce urmărește intervievatorul: La senior se urmărește apărarea în straturi și cunoașterea limitelor soluției în memorie. Răspunsul „pun un rate limiter” fără proxy și instanțe multiple e incomplet.

90 Senior

Unde ții cheia de semnare JWT și connection string-ul unui API ASP.NET Core, local și în producție? De ce, după ce ai trecut de la o instanță la trei, utilizatorii primesc erori la cookie-uri sau la tokenurile de resetare a parolei?

Răspuns scurt: Local în User Secrets, în producție în variabile de mediu sau într-un seif (Azure Key Vault, AWS Secrets Manager), niciodată în appsettings.json din Git. Cu mai multe instanțe, cheile Data Protection diferă pe fiecare server, deci o instanță nu decriptează ce a protejat alta.

Sistemul de configurare permite ca valoarea să vină din altă sursă decât fișierul, fără să schimbi codul care citește builder.Configuration["Jwt:Cheie"]:

  • Local: dotnet user-secrets set "Jwt:Cheie" "..."; secretele stau în profilul utilizatorului, în afara proiectului, și sunt încărcate automat în Development.
  • Producție: variabile de mediu (Jwt__Cheie) setate de orchestrator din secrete criptate (Kubernetes Secrets, setările aplicației în cloud), sau un seif dedicat (builder.Configuration.AddAzureKeyVault(...)) cu identitate gestionată, fără parole în configurare. Seiful aduce rotație, audit și permisiuni pe fiecare secret.
  • Repository: niciun secret în Git; un scanner de secrete în CI; dacă o cheie a ajuns totuși în istoric, o consideri compromisă și o rotești.

A doua parte este Data Protection, API-ul care criptează cookie-urile de autentificare, tokenurile antiforgery și tokenurile de resetare din Identity. Implicit, cheile sunt generate și salvate local, pe fiecare mașină sau în fiecare container. Cu trei instanțe în spatele unui load balancer, o cerere protejată de instanța A ajunge la B, care nu are cheia: cookie-ul pare invalid, utilizatorul este delogat, iar formularele dau erori antiforgery. După fiecare redeploy al unui container, cheile se pierd complet.

C#
builder.Services.AddDataProtection()
    .SetApplicationName("magazin")
    .PersistKeysToAzureBlobStorage(blobUri, credential)   // sau PersistKeysToDbContext / Redis
    .ProtectKeysWithAzureKeyVault(keyUri, credential);

Toate instanțele trebuie să citească același inel de chei, cu același nume de aplicație. Tokenurile JWT nu folosesc Data Protection, dar au aceeași cerință: toate instanțele validează cu aceeași cheie sau cu cheile publice ale aceluiași emitent.

Ce urmărește intervievatorul: Verifică maturitatea operațională: gestionarea secretelor și efectele trecerii la mai multe instanțe. Problema Data Protection o descoperă de obicei echipele în prima zi cu load balancer.

Testare, performanță și producție

91 Junior

Ce sunt health checks în ASP.NET Core și care e diferența dintre un endpoint de liveness și unul de readiness? Scrie configurarea pentru un API care depinde de o bază de date.

Răspuns scurt: Health checks sunt endpoint-uri pe care orchestratorul sau load balancer-ul le apelează ca să afle starea aplicației. Liveness spune „procesul trăiește, nu-l reporni”; readiness spune „pot primi trafic acum”, inclusiv dependențele. Le configurezi cu AddHealthChecks() și MapHealthChecks, filtrate prin tag-uri.

Fiecare verificare întoarce Healthy, Degraded sau Unhealthy; endpoint-ul răspunde 200 pentru primele două și 503 pentru ultima.

C#
builder.Services.AddHealthChecks()
    .AddCheck("self", () => HealthCheckResult.Healthy(), tags: ["live"])
    .AddDbContextCheck<AppDb>("baza-de-date", tags: ["ready"]);

var app = builder.Build();

app.MapHealthChecks("/health/live", new HealthCheckOptions
{
    Predicate = c => c.Tags.Contains("live")
});
app.MapHealthChecks("/health/ready", new HealthCheckOptions
{
    Predicate = c => c.Tags.Contains("ready")
});

AddDbContextCheck vine din pachetul Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore și încearcă o conexiune la bază.

De ce separi cele două:

  • Liveness trebuie să fie ieftin și să nu depindă de servicii externe. Dacă ar verifica baza de date, o pană de câteva secunde a bazei ar face Kubernetes să repornească toate instanțele API-ului, ceea ce înrăutățește situația.
  • Readiness include dependențele critice. Când pică, instanța e scoasă temporar din load balancer, fără repornire, și primește din nou trafic când își revine. E util și la pornire (încălzirea cache-ului, migrările) și la oprire.

Atenție la securitate: răspunsul implicit conține doar Healthy/Unhealthy. Dacă scrii un ResponseWriter cu detalii (mesaje de eroare, numele serverelor), expune endpoint-ul doar intern sau protejează-l cu RequireAuthorization sau RequireHost.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum interacționează aplicația cu infrastructura. Greșeala clasică: verificarea bazei de date în liveness.

92 Junior

Ce fac app.UseHttpsRedirection() și app.UseHsts()? De ce șablonul dotnet new webapi pune UseHsts doar în afara mediului Development?

Răspuns scurt: UseHttpsRedirection răspunde cererilor HTTP cu redirect (307 implicit) spre HTTPS. UseHsts adaugă antetul Strict-Transport-Security, prin care browserul ține minte să folosească doar HTTPS pentru domeniu. În Development nu se pune, pentru că browserul ar memora regula pentru localhost și ar strica alte proiecte locale.

Cele două middleware-uri rezolvă probleme diferite:

  • Redirecționarea prinde cererile venite pe http:// și le trimite la https:// cu același path și query. Prima cerere a călătorit totuși în clar, deci un atacator pe aceeași rețea o poate intercepta sau modifica (SSL stripping).
  • HSTS închide această fereastră pentru vizitele următoare: după ce browserul primește Strict-Transport-Security: max-age=31536000; includeSubDomains, transformă singur orice http:// în https:// pentru acel domeniu, fără să mai trimită cererea nesigură.
C#
if (!app.Environment.IsDevelopment())
{
    app.UseHsts();
}
app.UseHttpsRedirection();

builder.Services.AddHsts(o =>
{
    o.MaxAge = TimeSpan.FromDays(365);
    o.IncludeSubDomains = true;
    o.Preload = true;
});

De ce nu în Development: antetul e memorat de browser pentru tot domeniul. Pentru localhost, toate aplicațiile pe care le rulezi local, pe orice port, ar fi forțate pe HTTPS. ASP.NET Core exclude oricum localhost din HSTS, dar șablonul e prudent.

Contextul de producție: de multe ori TLS-ul se termină la un load balancer sau reverse proxy, iar aplicația primește HTTP. Fără UseForwardedHeaders configurat, UseHttpsRedirection crede că fiecare cerere e HTTP și poate produce bucle de redirect. Pentru un API consumat doar de alte servicii, unele echipe preferă să nu asculte deloc pe HTTP, în loc să redirecționeze, pentru că clienții API nu urmează mereu redirectul și ar trimite tokenul în clar.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre redirect și HSTS și efectele unui reverse proxy. Mulți candidați spun doar „forțează HTTPS”.

93 Junior

Scrie un BackgroundService care șterge sesiunile expirate o dată la 5 minute. Ce se întâmplă dacă ExecuteAsync aruncă o excepție și cum oprești corect serviciul la închiderea aplicației?

Răspuns scurt: Folosești un PeriodicTimer într-o buclă cu stoppingToken, creezi un scope per execuție pentru serviciile scoped și prinzi excepțiile în buclă. Din .NET 6, o excepție neprinsă în ExecuteAsync oprește implicit tot host-ul (BackgroundServiceExceptionBehavior.StopHost). La oprire, token-ul e anulat și bucla iese.

BackgroundService implementează IHostedService: host-ul cheamă StartAsync la pornire, care lansează ExecuteAsync, și StopAsync la oprire, care anulează stoppingToken.

C#
public class CuratareSesiuni(IServiceScopeFactory scopuri, ILogger<CuratareSesiuni> log)
    : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromMinutes(5));
        do
        {
            try
            {
                using var scope = scopuri.CreateScope();
                var db = scope.ServiceProvider.GetRequiredService<AppDb>();
                var sterse = await db.Sesiuni
                    .Where(s => s.Expira < DateTime.UtcNow)
                    .ExecuteDeleteAsync(stoppingToken);
                log.LogInformation("Am șters {Numar} sesiuni expirate", sterse);
            }
            catch (Exception ex) when (ex is not OperationCanceledException)
            {
                log.LogError(ex, "Curățarea sesiunilor a eșuat");
            }
        }
        while (await timer.WaitForNextTickAsync(stoppingToken));
    }
}

builder.Services.AddHostedService<CuratareSesiuni>();

Puncte importante:

  • Serviciul e singleton, deci AppDb se obține dintr-un scope creat pentru fiecare execuție.
  • try/catch în buclă: o eroare temporară a bazei de date nu trebuie să oprească aplicația. Fără el, în .NET 6+ excepția oprește host-ul; în versiunile mai vechi serviciul murea în tăcere.
  • WaitForNextTickAsync(stoppingToken) aruncă OperationCanceledException la oprire, iar BackgroundService o tratează ca terminare normală.
  • Codul sincron lung de la începutul lui ExecuteAsync, înainte de primul await, blochează pornirea aplicației.
  • Cu mai multe instanțe ale API-ului, jobul rulează pe fiecare. Pentru joburi care trebuie să ruleze o singură dată, folosești un lock distribuit sau un planificator separat (Hangfire, Quartz, un job de cron în orchestrator).

Ce urmărește intervievatorul: Verifică dacă știi ciclul de viață al serviciilor găzduite și comportamentul la erori. Mulți candidați injectează DbContext direct și nu tratează excepțiile.

94 Junior

Ești de serviciu și primești o alertă: POST /api/comenzi răspunde 500 pentru o parte dintre utilizatori în producție, iar local nu reușești să reproduci problema. Descrie pașii pe care îi urmezi.

Răspuns scurt: Întâi limitez impactul (rollback dacă problema a apărut după un deploy), apoi adun date: logurile și trace-ul cererilor eșuate după traceId, ce au în comun utilizatorii afectați, ce s-a schimbat recent. Reproduc cu datele lor într-un mediu de test, repar, adaug un test și monitorizez.

Un model de răspuns structurat:

1. Stabilizez. Verific dacă problema a început după un deploy sau o schimbare de configurare. Dacă da și eroarea afectează multe comenzi, rollback-ul e prima opțiune; investigația continuă după. Anunț echipa și pe cei afectați, conform procesului de incident.

2. Adun date, nu ipoteze. În Production, clientul vede doar un 500 sau un ProblemDetails generic, dar logurile au excepția completă. Caut după traceId (apare în ProblemDetails și în loguri), iar cu OpenTelemetry văd trace-ul: ce dependență a eșuat, cât a durat fiecare pas.

3. Caut tiparul. Ce au în comun cererile eșuate? Un anumit client sau versiune a aplicației mobile, un câmp din corp (diacritice, valoare lipsă, o dată în alt format), o anumită instanță (configurare diferită, disc plin), o anumită oră (job de fundal care blochează tabele). Diferențele dintre local și producție sunt de obicei datele, configurarea, volumul și concurența.

4. Reproduc. Construiesc cererea exactă dintr-un log (fără date personale) și o trimit într-un mediu de staging cu aceeași versiune. Dacă e o problemă de concurență (DbUpdateConcurrencyException, „A second operation was started”), o reproduc cu cereri paralele.

5. Repar și previn. Fixul vine cu un test care eșua înainte. Dacă excepția era de fapt o eroare de validare, endpoint-ul ar trebui să întoarcă 400 cu un mesaj clar, nu 500. Adaug o alertă pe rata de 5xx și scriu un post-mortem scurt, fără vinovați: cauză, impact, ce schimbăm.

Ce urmărește intervievatorul: Întrebarea comportamentală verifică metoda: dacă pornești de la date (loguri, trace) și te gândești la impact. Răspunsul slab este „pun breakpoint-uri” sau „mă uit prin cod”.

Eroarea, în practică:An unhandled exception has occurred (500)

95 Mid

Care este diferența dintre response caching (UseResponseCaching) și output caching (AddOutputCache, .NET 7+)? Cum ai pune în cache lista de produse și ai invalida-o când se adaugă un produs?

Răspuns scurt: Response caching respectă antetele HTTP Cache-Control ale clientului și ale răspunsului, deci un client poate ocoli cache-ul. Output caching este controlat de server: politici per endpoint, variații după query, tag-uri și invalidare explicită cu EvictByTagAsync. Pentru un API, output caching e de obicei alegerea potrivită.

UseResponseCaching implementează regulile cache-urilor HTTP: pune răspunsul în cache doar dacă are Cache-Control: public, max-age=... și ignoră cache-ul dacă cererea trimite Cache-Control: no-cache. Practic, oricine poate forța recalcularea, iar răspunsurile pentru utilizatori autentificați nu sunt puse în cache. E util mai ales ca să setezi corect antetele pentru browser și CDN.

Output caching ține răspunsul pe server, după reguli pe care le alegi tu:

C#
builder.Services.AddOutputCache(o =>
{
    o.AddPolicy("Produse", p => p
        .Expire(TimeSpan.FromMinutes(5))
        .SetVaryByQuery("categorie", "pagina")
        .Tag("produse"));
});

var app = builder.Build();
app.UseOutputCache();

app.MapGet("/produse", (string? categorie, int pagina, AppDb db) => ...)
   .CacheOutput("Produse");

app.MapPost("/produse", async (ProdusNou p, AppDb db, IOutputCacheStore cache, CancellationToken ct) =>
{
    // ... salvare
    await cache.EvictByTagAsync("produse", ct);
    return Results.Created(...);
});

Avantaje: protecție la „cache stampede” (cereri simultane pentru aceeași cheie așteaptă un singur calcul), invalidare prin tag-uri, magazin înlocuibil (Redis, din .NET 8). Implicit, nu pune în cache cererile autentificate sau cele care setează cookie-uri, ca să nu servească datele unui utilizator altuia.

Când nu cache-uiești răspunsul întreg: date per utilizator, sau când doar o parte e scumpă. Atunci pui în cache datele, nu răspunsul, cu IMemoryCache, IDistributedCache sau HybridCache (.NET 9), care combină un cache local cu unul distribuit și protecție la stampede.

Ce urmărește intervievatorul: Verifică dacă știi instrumentele concrete din framework și diferența de control. Răspunsul ideal menționează și invalidarea, nu doar adăugarea în cache.

96 Mid

Ai teste de integrare cu WebApplicationFactory<Program>. Cum înlocuiești baza de date reală cu una de test și cum testezi un endpoint protejat cu JWT fără server de autentificare?

Răspuns scurt: Derivezi din WebApplicationFactory<Program> și, în ConfigureWebHost, folosești ConfigureTestServices ca să scoți înregistrarea DbContextOptions<AppDb> și să adaugi una pe SQLite în memorie sau pe un container de test. Pentru autentificare, adaugi o schemă de test (AuthenticationHandler) care creează utilizatorul din antete.

ConfigureTestServices rulează după înregistrările din Program.cs, deci poți înlocui orice serviciu:

C#
public class FabricaApi : WebApplicationFactory<Program>
{
    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.UseEnvironment("Testing");
        builder.ConfigureTestServices(services =>
        {
            services.RemoveAll<DbContextOptions<AppDb>>();
            var conexiune = new SqliteConnection("DataSource=:memory:");
            conexiune.Open();
            services.AddDbContext<AppDb>(o => o.UseSqlite(conexiune));

            services.AddAuthentication("Test")
                .AddScheme<AuthenticationSchemeOptions, AutentificareTest>("Test", _ => { });
        });
    }
}

public class AutentificareTest(IOptionsMonitor<AuthenticationSchemeOptions> o,
    ILoggerFactory l, UrlEncoder e) : AuthenticationHandler<AuthenticationSchemeOptions>(o, l, e)
{
    protected override Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        if (!Request.Headers.TryGetValue("X-Test-User", out var user))
            return Task.FromResult(AuthenticateResult.NoResult());
        var id = new ClaimsIdentity([new Claim(ClaimTypes.Name, user!)], "Test");
        return Task.FromResult(AuthenticateResult.Success(
            new AuthenticationTicket(new ClaimsPrincipal(id), "Test")));
    }
}

Detalii de discutat:

  • Schema de test trebuie să fie implicită (AddAuthentication("Test") schimbă schema implicită) sau politicile trebuie să o includă.
  • SQLite în memorie e mai realist decât providerul InMemory (are constrângeri, tranzacții, SQL), dar diferă tot de SQL Server; pentru fidelitate maximă se folosesc containere (Testcontainers).
  • Conexiunea SQLite trebuie ținută deschisă, altfel baza dispare.
  • Testele de integrare rulează în paralel pe clase: fiecare clasă cu propriul factory și propria bază, sau date izolate, ca testele să nu se influențeze.
  • Pentru testul complet al configurării JWT, poți genera tokenuri reale semnate cu o cheie de test din configurația mediului Testing.

Ce urmărește intervievatorul: Verifică dacă ai scris efectiv teste de integrare dincolo de exemplul de bază. Un candidat bun discută fidelitatea providerului și izolarea datelor.

Eroarea, în practică:Assert.Equal: Expected OK, Actual UnauthorizedHttpRequestException: status code 401 (Unauthorized)

97 Mid

Aplicația rulează în Kubernetes. La fiecare deploy, câteva cereri primesc erori de conexiune sau 502. Ce se întâmplă cu cererile în curs când procesul ASP.NET Core primește SIGTERM și cum faci oprirea „grațioasă”?

Răspuns scurt: La SIGTERM, Kestrel nu mai acceptă conexiuni noi și așteaptă cererile în curs până la ShutdownTimeout (30 de secunde în .NET 8+), apoi oprește serviciile găzduite. 502-urile apar când pod-ul mai primește trafic după oprire; rezolvi cu readiness și o scurtă întârziere.

Secvența de oprire în .NET:

1. Procesul primește SIGTERM (sau Ctrl+C). IHostApplicationLifetime.ApplicationStopping este anulat. 2. Kestrel închide socket-urile de ascultare și așteaptă cererile active; HttpContext.RequestAborted nu e anulat imediat. 3. StopAsync este apelat pe serviciile găzduite (în ordine inversă înregistrării), cu un token care expiră după HostOptions.ShutdownTimeout. 4. După expirarea timpului, ce nu s-a terminat e abandonat.

C#
builder.Services.Configure<HostOptions>(o => o.ShutdownTimeout = TimeSpan.FromSeconds(25));

De ce apar totuși erori: Kubernetes trimite SIGTERM și scoate pod-ul din lista de endpoint-uri a serviciului în paralel. Câteva secunde, load balancer-ul sau kube-proxy pot trimite cereri noi către un pod care nu mai acceptă conexiuni. Remedii uzuale:

  • un hook preStop cu sleep 5–10 (sau o întârziere în ApplicationStopping), ca rutarea să se actualizeze înainte de oprirea lui Kestrel;
  • readiness probe care începe să întoarcă 503 la oprire;
  • terminationGracePeriodSeconds mai mare decât întârzierea plus ShutdownTimeout;
  • strategia de rolling update cu maxUnavailable: 0, ca podurile noi să fie gata înaintea opririi celor vechi.

În cod: transmite CancellationToken operațiilor lungi și verifică-l, ca un BackgroundService să se oprească în timp util; nu porni lucru nou după ApplicationStopping; pentru operații care nu trebuie pierdute (trimiterea unui email, procesarea unei plăți), folosește o coadă durabilă, nu memoria procesului.

Ce urmărește intervievatorul: Verifică dacă înțelegi ciclul de viață al host-ului și interacțiunea cu orchestratorul. Răspunsurile superficiale se opresc la „Kestrel termină cererile”.

98 Mid

Aplicația mobilă folosește GET /api/comenzi/{id}, care întoarce "total": 199.9. Echipa vrea să redenumească câmpul în "valoareTotala" și să adauge moneda. Cum procedezi, știind că utilizatorii nu își actualizează toți aplicația imediat?

Răspuns scurt: Redenumirea este o schimbare incompatibilă, deci nu o fac direct. Adaug câmpurile noi lângă cel vechi, marchez total ca depreciat, măsor cine îl mai folosește și îl scot când versiunile vechi nu mai au utilizatori. Pentru schimbări mari, introduc o versiune nouă.

Un model de răspuns structurat:

1. Clasific schimbarea. Adăugarea unui câmp e compatibilă (clienții ignoră câmpurile necunoscute, dacă așa au fost scriși). Redenumirea sau ștergerea unui câmp, schimbarea tipului sau a sensului (de exemplu total în bani în loc de lei) sunt incompatibile: versiunile vechi ale aplicației mobile ar afișa nimic sau ar crăpa.

2. Aleg strategia de expandare și contractare. Pasul unu: DTO-ul întoarce ambele câmpuri.

C#
public record ComandaDto(int Id,
    [property: Obsolete("Folosește ValoareTotala")] decimal Total,
    decimal ValoareTotala,
    string Moneda);

Documentez în OpenAPI că total e depreciat și anunț data retragerii. Pasul doi: aplicația mobilă nouă trece pe valoareTotala. Pasul trei: urmăresc în loguri sau metrici versiunea aplicației din antetul User-Agent sau dintr-un antet propriu și aștept până când versiunile vechi sunt neglijabile; abia apoi scot câmpul.

3. Dacă schimbarea e mare, prefer o versiune nouă (/api/v2/comenzi), cu aceeași logică de domeniu și alt DTO, și o politică de suport pentru v1.

4. Previn surprizele: teste de contract pe DTO-uri (snapshot al JSON-ului), ca o redenumire de proprietate în C# să nu schimbe accidental contractul public, și entitățile EF niciodată întoarse direct din API.

5. Comunic: echipa de mobil decide împreună cu mine termenele; pentru aplicații vechi fără actualizare, se poate cere o versiune minimă la pornire.

Ce urmărește intervievatorul: Întrebarea comportamentală verifică gândirea de contract și colaborarea cu alte echipe. Răspunsul slab este „redenumesc și le spun să actualizeze”.

99 Senior

Compania are un API mare scris în ASP.NET Web API 2 pe .NET Framework 4.8 și vrea să ajungă pe ASP.NET Core și .NET 8, fără să oprească dezvoltarea de funcționalități noi. Cum ai planifica migrarea?

Răspuns scurt: Evit rescrierea completă și fac o migrare incrementală „strangler fig”: un reverse proxy (YARP) în fața aplicației vechi, endpoint-urile mutate pe rând într-o aplicație ASP.NET Core nouă, codul comun mutat întâi pe .NET Standard, iar aplicația veche oprită când nu mai primește trafic.

Un plan structurat, ca model de răspuns:

1. Inventar. Ce folosește aplicația și ce nu există în ASP.NET Core: System.Web și HttpContext.Current, module și handlere HTTP, Global.asax, WCF, sesiuni, autentificare Windows sau formulare, biblioteci fără variantă modernă. Unealta .NET Upgrade Assistant și analizoarele de portabilitate dau o primă listă.

2. Pregătesc codul comun. Logica de domeniu și accesul la date le mut în biblioteci care țintesc netstandard2.0 sau multi-target (net48;net8.0), ca ambele aplicații să le folosească. EF6 poate rula și pe .NET modern, dar trecerea la EF Core e un proiect separat, nu o condiție.

3. Strangler fig cu YARP. Creez aplicația ASP.NET Core nouă, care primește tot traficul și îl trimite prin YARP la aplicația veche pentru ce nu a fost migrat:

C#
builder.Services.AddReverseProxy()
    .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));
// ...
app.MapControllers();          // endpoint-urile deja migrate
app.MapReverseProxy();         // restul ajung la aplicația .NET Framework

Pachetele System.Web adapters ajută la partajarea sesiunii și a autentificării între cele două aplicații.

4. Migrez pe felii verticale, de la endpoint-urile simple și cu trafic mic spre cele critice, cu teste de contract care compară răspunsurile vechi și noi. Funcționalitățile noi se scriu direct în aplicația nouă.

5. Măsor și închei. Urmăresc traficul care mai ajunge la aplicația veche; când e zero, o opresc.

Riscurile pe care le discut deschis: diferențe de serializare JSON (Newtonsoft față de System.Text.Json), comportamente implicite schimbate (rutare, model binding, majuscule), autentificare și durata totală. Planul trebuie să poată fi oprit oricând fără să lase produsul într-o stare ruptă.

Ce urmărește intervievatorul: La senior se urmărește capacitatea de a planifica o schimbare mare cu risc mic. Propunerea unei rescrieri complete „big bang” este semnalul cel mai rău.

100 Senior

Cum adaugi observabilitate cu OpenTelemetry unui API ASP.NET Core care apelează o bază de date și un alt serviciu HTTP? Ce câștigi față de loguri simple?

Răspuns scurt: Adaugi pachetele OpenTelemetry, configurezi AddOpenTelemetry().WithTracing(...).WithMetrics(...) cu instrumentarea ASP.NET Core, HttpClient și a bazei de date și un exporter OTLP. Câștigi trace-uri distribuite: o cerere urmărită prin toate serviciile, cu durata fiecărui pas, corelate cu logurile prin TraceId.

Logurile spun ce s-a întâmplat într-un proces. Când o cerere trece prin API, apoi printr-un serviciu de plăți și o bază de date, ai nevoie de trace-uri distribuite: fiecare pas este un span cu început, durată, atribute și părinte, iar contextul (traceparent, standard W3C) se propagă automat prin antetele HTTP.

C#
builder.Services.AddOpenTelemetry()
    .ConfigureResource(r => r.AddService("api-comenzi"))
    .WithTracing(t => t
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddEntityFrameworkCoreInstrumentation()
        .AddSource("Magazin.Comenzi")
        .AddOtlpExporter())
    .WithMetrics(m => m
        .AddAspNetCoreInstrumentation()
        .AddRuntimeInstrumentation()
        .AddMeter("Magazin.Comenzi")
        .AddOtlpExporter());

builder.Logging.AddOpenTelemetry(l => l.AddOtlpExporter());

Span-uri proprii pentru operații de business:

C#
static readonly ActivitySource Sursa = new("Magazin.Comenzi");

using var activitate = Sursa.StartActivity("PlaseazaComanda");
activitate?.SetTag("comanda.produse", comanda.Linii.Count);

Ce câștigi concret: vezi că un POST /comenzi de 2 secunde petrece 1,8 secunde în serviciul de plăți; metrici standard (http.server.request.duration pe rută și status) pentru alerte pe latență și rata de erori; loguri care conțin TraceId și SpanId, deci de la o eroare ajungi direct la trace.

Decizii de producție: exporterul OTLP trimite la un colector (OpenTelemetry Collector), care alege backend-ul (Jaeger, Grafana Tempo, Azure Monitor), deci codul nu depinde de furnizor. Configurezi eșantionarea (nu toate trace-urile sunt păstrate), nu pui date personale în atribute și nu folosești valori nelimitate (id-uri de utilizator) ca dimensiuni de metrici, pentru că explodează costul. .NET Aspire configurează toate acestea implicit în proiectele noi.

Ce urmărește intervievatorul: La senior se verifică dacă știi să faci un sistem observabil, nu doar să scrii loguri. Un răspuns bun discută propagarea contextului, eșantionarea și costul.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de ASP.NET Core, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață ASP.NET Core scriind cod, nu doar citind

Curs ASP.NET Core: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 20 lecții sunt gratuite.