...
Pregătire interviuri

100 de întrebări de interviu pentru Developer C# / .NET, cu răspunsuri

Întrebările care apar des la interviurile de Developer C# / .NET, 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.

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

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 140 minde citit
Întrebări de interviu Developer C# / .NET cu răspunsuri

Un proces de interviu pentru un post de developer C# / .NET începe de obicei cu o discuție scurtă cu recruiterul sau cu HR-ul, în care se verifică motivația, disponibilitatea și așteptările. Urmează unul sau două interviuri tehnice: întrebări despre limbaj (tipuri valoare și referință, LINQ, async/await, garbage collector), despre ASP.NET Core și Entity Framework Core, plus SQL de bază. Multe firme adaugă o temă de casă (de exemplu un mic API REST cu bază de date și teste) sau un exercițiu de programare live, urmat de o discuție despre codul tău.

La nivel junior, intervievatorul vrea să vadă că înțelegi fundamentele și că poți explica de ce funcționează lucrurile așa cum funcționează, nu doar că ai memorat definiții: diferența dintre class și struct, ce face await, ce înseamnă un JOIN, cum folosești Git zi de zi. La nivel mid, accentul se mută pe decizii și pe consecințe: durata de viață a serviciilor în dependency injection, problema N+1 în EF Core, deadlock-uri cu .Result, cum testezi un serviciu care depinde de baza de date. La senior apar întrebări despre performanță, memorie, concurență și arhitectură.

Pagina are 100 de întrebări grupate pe teme, fiecare cu un răspuns scurt (ce ai spune în primele zece secunde), un răspuns detaliat cu exemple de cod și o notă despre ce urmărește de fapt intervievatorul. Citește întâi răspunsul scurt și încearcă să-l formulezi cu cuvintele tale, apoi verifică-te cu explicația completă. Rulează exemplele de cod într-un proiect dotnet new console ca să le înțelegi cu adevărat, iar la întrebările comportamentale pregătește-ți propriile povești, după modelul dat.

Limbajul C# și sistemul de tipuri

1 Junior

Care este diferența dintre tipurile valoare și tipurile referință în C#?

Răspuns scurt: Un tip valoare (struct, int, bool, enum) își conține direct datele și se copiază la atribuire. Un tip referință (class, string, array) conține o referință către un obiect de pe heap, iar atribuirea copiază doar referința.

Tipurile valoare (int, double, bool, DateTime, enum, orice struct) țin datele direct în variabilă. Când faci b = a, se copiază toată valoarea, deci modificarea lui b nu-l afectează pe a. Tipurile referință (class, string, tablouri, delegați, record class) țin în variabilă o referință către un obiect alocat pe heap. La atribuire se copiază referința, deci două variabile pot indica același obiect.

C#
struct PunctS { public int X; }
class PunctC { public int X; }

var s1 = new PunctS { X = 1 };
var s2 = s1; s2.X = 99;
Console.WriteLine(s1.X); // 1

var c1 = new PunctC { X = 1 };
var c2 = c1; c2.X = 99;
Console.WriteLine(c1.X); // 99

Alte diferențe practice:

  • tipurile valoare nu pot fi null decât ca Nullable<T> (int?);
  • tipurile valoare nu suportă moștenire (doar implementează interfețe);
  • comparația implicită == la clase compară referințele, la struct-uri trebuie definită.

Atenție la mitul „valorile stau pe stack, referințele pe heap”: un int care e câmp într-o clasă stă pe heap, în interiorul obiectului. Ce contează e semantica de copiere, nu locul din memorie.

Ce urmărește intervievatorul: Verifică dacă înțelegi semantica de copiere, baza pentru multe bug-uri. Greșeala tipică e să reduci totul la „stack vs heap”.

2 Junior

Când ai alege un struct în loc de o clasă?

Răspuns scurt: Alegi struct pentru valori mici, imutabile, fără identitate proprie, cum ar fi un punct, o sumă de bani sau o coordonată. Pentru entități cu identitate, stare care se schimbă sau dimensiuni mari, alegi clasă.

Un struct are sens când obiectul se comportă ca o valoare: două instanțe cu aceleași date sunt practic „același lucru”, ca două numere egale. Exemple din .NET: DateTime, TimeSpan, Guid, decimal.

Recomandările Microsoft pentru struct-uri:

  • dimensiune mică (orientativ sub 16 octeți), pentru că se copiază la fiecare atribuire și la fiecare transmitere ca parametru;
  • imutabil, de preferat readonly struct;
  • nu e transformat des în object sau interfață, pentru că asta înseamnă boxing (alocare pe heap).
C#
public readonly struct Bani
{
    public decimal Suma { get; }
    public string Moneda { get; }
    public Bani(decimal suma, string moneda) => (Suma, Moneda) = (suma, moneda);
    public Bani Adauga(decimal x) => new Bani(Suma + x, Moneda);
}

Clasa e potrivită pentru entități (un Client, o Comanda), pentru obiecte mari, pentru ierarhii cu moștenire și pentru obiecte partajate între mai multe locuri din cod. Un struct mutabil e o sursă clasică de bug-uri: modifici o copie și te miri că originalul a rămas neschimbat, de exemplu când iei un element dintr-o List<T> de struct-uri. Avantajul struct-ului e că evită alocări pe heap și presiunea pe garbage collector în bucle strânse sau colecții mari.

Ce urmărește intervievatorul: Intervievatorul vrea criterii concrete, nu „struct e mai rapid”. Greșeala tipică e să propui struct-uri mari sau mutabile.

3 Junior

Ce fac cuvintele cheie ref, out și in la parametri?

Răspuns scurt: Toate trei transmit argumentul prin referință. ref cere variabilă inițializată și permite citire și scriere, out obligă metoda să atribuie o valoare, iar in transmite prin referință doar pentru citire.

Implicit, C# transmite argumentele prin valoare: pentru un int se copiază numărul, pentru o clasă se copiază referința. Cu ref, out și in, metoda primește un alias către variabila apelantului.

  • ref: variabila trebuie inițializată înainte de apel; metoda o poate citi și modifica.
  • out: variabila nu trebuie inițializată; metoda este obligată să-i atribuie o valoare înainte de return. Folosit pentru „mai multe valori de retur”, ca în int.TryParse.
  • in: transmitere prin referință doar pentru citire, utilă pentru struct-uri mari, ca să eviți copierea.
C#
void Dubleaza(ref int x) => x *= 2;

int n = 5;
Dubleaza(ref n);
Console.WriteLine(n); // 10

if (int.TryParse("42", out int valoare))
    Console.WriteLine(valoare + 1); // 43

O confuzie frecventă: dacă transmiți un obiect de tip clasă fără ref, metoda poate modifica proprietățile obiectului (pentru că are o copie a referinței), dar nu poate face ca variabila apelantului să indice alt obiect. Cu ref poate face și asta. În cod modern, out se folosește mai ales în modelul TryXxx, iar pentru mai multe rezultate se preferă tuple-uri: (int min, int max) Calc().

Ce urmărește intervievatorul: Se verifică înțelegerea transmiterii parametrilor. Mulți candidați cred greșit că obiectele sunt transmise „prin referință” implicit.

4 Junior

De ce string este imutabil și când folosești StringBuilder?

Răspuns scurt: Un string nu poate fi modificat după creare; orice operație creează un string nou. În bucle care construiesc text din multe bucăți, StringBuilder evită crearea a zeci sau mii de obiecte intermediare.

string este un tip referință, dar imutabil: metode ca Replace, ToUpper sau operatorul + întorc un string nou și lasă originalul neatins. Avantaje: string-urile pot fi partajate în siguranță între thread-uri, pot fi folosite ca chei în Dictionary fără riscul de a-și schimba hash-ul, iar literalii identici pot fi reținuți o singură dată (string interning).

Dezavantajul apare la concatenare repetată:

C#
string s = "";
for (int i = 0; i < 10000; i++)
    s += i; // creează 10000 de string-uri, fiecare copiind tot textul anterior

var sb = new StringBuilder();
for (int i = 0; i < 10000; i++)
    sb.Append(i); // un buffer care crește la nevoie
string rezultat = sb.ToString();

Varianta cu += are complexitate pătratică, pentru că fiecare pas copiază tot ce s-a acumulat. StringBuilder păstrează un buffer intern și creează string-ul final o singură dată.

Pentru câteva concatenări ($"{nume} {prenume}") nu ai nevoie de StringBuilder; compilatorul optimizează interpolarea și string.Concat. Pentru a uni o colecție, string.Join(", ", lista) este cea mai clară soluție. Regula practică: StringBuilder când numărul de bucăți nu e cunoscut sau e mare, de obicei într-o buclă.

Ce urmărește intervievatorul: Verifică înțelegerea imutabilității și a costului alocărilor. Greșeala tipică: „StringBuilder e mereu mai rapid”, chiar și pentru două concatenări.

5 Junior

Care este diferența dintre == și Equals()?

Răspuns scurt: Pentru clase, == compară implicit referințele, iar Equals() poate fi suprascris pentru egalitate după conținut. string, record-urile și tipurile care supraîncarcă operatorul fac ca == să compare valorile.

Equals() este o metodă virtuală din object, deci comportamentul ei depinde de tipul real al obiectului la rulare. Operatorul == este rezolvat la compilare, după tipul declarat al variabilelor.

  • Pentru clase obișnuite, ambele compară referințele, dacă nu le suprascrii.
  • Pentru string, ambele compară conținutul, pentru că string supraîncarcă == și suprascrie Equals.
  • Pentru struct-uri, Equals implicit compară câmp cu câmp (prin reflection, deci lent), iar == nu există până nu-l definești.
  • Pentru record, compilatorul generează egalitate pe valori pentru ambele.
C#
object a = "salut";
object b = new string("salut".ToCharArray());

Console.WriteLine(a == b);      // False: == pe object compară referințe
Console.WriteLine(a.Equals(b)); // True: se apelează string.Equals

Exemplul arată capcana: tipul declarat este object, deci == folosește comparația de referințe, deși obiectele sunt string-uri. Când suprascrii Equals, trebuie să suprascrii și GetHashCode, altfel obiectele egale vor ajunge în bucket-uri diferite într-un Dictionary sau HashSet. Pentru egalitate pe valori fără cod repetitiv, un record este de obicei soluția cea mai simplă.

Ce urmărește intervievatorul: Testează diferența dintre rezolvarea la compilare și polimorfism. Mulți uită regula Equals plus GetHashCode.

6 Junior

Ce sunt tipurile nullable și cum folosești operatorii ?., ?? și ??=?

Răspuns scurt: int? (adică Nullable<int>) permite unui tip valoare să fie null. ?. apelează un membru doar dacă obiectul nu e null, ?? dă o valoare implicită pentru null, iar ??= atribuie doar dacă variabila e null.

Un tip valoare ca int are mereu o valoare, deci nu poate reprezenta „lipsă”. int? este prescurtarea pentru Nullable<int>, un struct cu două câmpuri: HasValue și Value. Este util pentru coloane SQL care permit NULL sau pentru câmpuri opționale dintr-un formular.

C#
int? varsta = null;
Console.WriteLine(varsta.HasValue);   // False
int v = varsta ?? 18;                 // 18
Console.WriteLine(varsta.GetValueOrDefault()); // 0

string? oras = client?.Adresa?.Oras;  // null dacă client sau Adresa e null
int lungime = oras?.Length ?? 0;

List<string>? cache = null;
cache ??= new List<string>();         // se creează doar dacă e null

Cum funcționează:

  • ?. (null-conditional) întrerupe lanțul și întoarce null dacă partea din stânga e null, evitând NullReferenceException;
  • ?? (null-coalescing) întoarce operandul din dreapta dacă cel din stânga e null;
  • ??= (C# 8+) atribuie doar dacă variabila e null.

Atenție: varsta.Value pe un nullable fără valoare aruncă InvalidOperationException. Și nu abuza de ?. peste tot: dacă un obiect nu ar trebui să fie niciodată null, e mai bine să eșuezi devreme, cu o excepție clară, decât să propagi null în tăcere.

Ce urmărește intervievatorul: Verifică dacă știi să scrii cod defensiv fără if-uri imbricate. Greșeala tipică e folosirea .Value fără verificare.

7 Junior

Care este diferența dintre const, readonly și static readonly?

Răspuns scurt: const este o constantă de compilare, copiată în codul care o folosește. readonly se setează o singură dată, la declarare sau în constructor, per instanță. static readonly este o singură valoare per tip, calculată la rulare.

  • const: valoarea trebuie cunoscută la compilare (numere, string-uri, bool, enum, null). Este implicit statică. Compilatorul copiază valoarea direct în fiecare loc unde e folosită, chiar și în alte assembly-uri.
  • readonly: câmp care poate fi atribuit doar la declarare sau în constructor. Fiecare instanță poate avea altă valoare.
  • static readonly: un singur câmp pentru tot tipul, inițializat la rulare, deci poate fi orice obiect (DateTime.Now, o listă, un HttpClient).
C#
public class Setari
{
    public const int MaxIncercari = 3;
    public static readonly TimeSpan Timeout = TimeSpan.FromSeconds(30);
    private readonly string _conexiune;

    public Setari(string conexiune) => _conexiune = conexiune;
}

Capcana cu const public: dacă biblioteca A definește const int Versiune = 1 și aplicația B o folosește, B are valoarea 1 „lipită” în IL-ul ei. Dacă A schimbă la 2 și nu recompilezi B, B vede tot 1. De aceea, pentru valori care se pot schimba între versiuni, se preferă static readonly.

Atenție și la faptul că readonly protejează doar referința: un câmp readonly List<int> nu poate fi reatribuit, dar lista poate fi modificată cu Add. Pentru colecții cu adevărat nemodificabile folosești IReadOnlyList<T> sau ImmutableArray<T>.

Ce urmărește intervievatorul: Intervievatorul caută detaliul despre copierea valorii const între assembly-uri și faptul că readonly nu face obiectul imutabil.

8 Junior

Care este diferența dintre var, object și dynamic?

Răspuns scurt: var înseamnă tip dedus la compilare, la fel de strict ca un tip scris explicit. object este tipul de bază al tuturor tipurilor și cere cast. dynamic amână verificarea tipului până la rulare.

var nu înseamnă „orice tip”. Compilatorul deduce tipul din expresia din dreapta și variabila rămâne de acel tip. var x = 5; este identic cu int x = 5;, iar x = "text"; nu compilează. Se folosește pentru lizibilitate, când tipul e evident, și este obligatoriu la tipuri anonime (var p = new { Nume = "Ana" };).

object este baza tuturor tipurilor. Poți pune orice într-o variabilă object, dar ca să accesezi membrii specifici ai obiectului trebuie să faci cast. Pentru tipurile valoare, conversia în object înseamnă boxing.

dynamic dezactivează verificarea la compilare: orice apel de membru compilează, iar rezolvarea se face la rulare prin Dynamic Language Runtime. Dacă membrul nu există, primești RuntimeBinderException.

C#
var a = "text";     // string
object b = "text";
dynamic c = "text";

Console.WriteLine(a.Length);           // OK
Console.WriteLine(((string)b).Length); // e nevoie de cast
Console.WriteLine(c.Length);           // OK, rezolvat la rulare
// Console.WriteLine(c.Lungime);       // compilează, dar aruncă la rulare

În practică, dynamic se folosește rar: interoperabilitate COM, unele scenarii cu JSON sau limbaje dinamice. Pierzi IntelliSense, verificarea tipurilor și performanța. Pentru JSON, de obicei e mai bine să deserializezi într-o clasă tipizată.

Ce urmărește intervievatorul: Verifică dacă știi că var este tipizare statică. Greșeala clasică e să confunzi var cu dynamic.

9 Junior

Cum funcționează try, catch și finally și care e diferența dintre throw și throw ex?

Răspuns scurt: try conține codul care poate arunca, catch tratează excepțiile potrivite, iar finally rulează mereu. throw; re-aruncă excepția păstrând stack trace-ul original, pe când throw ex; îl resetează la linia curentă.

Blocurile catch sunt evaluate în ordine, deci excepțiile specifice se pun înaintea celor generale. finally se execută indiferent dacă a apărut o excepție sau s-a făcut return, fiind locul pentru eliberarea resurselor (deși using e de obicei mai elegant).

C#
try
{
    var text = File.ReadAllText(cale);
    Proceseaza(text);
}
catch (FileNotFoundException ex)
{
    _logger.LogWarning(ex, "Fișierul {Cale} lipsește", cale);
}
catch (Exception ex) when (ex is not OperationCanceledException)
{
    _logger.LogError(ex, "Eroare la procesare");
    throw; // păstrează stack trace-ul
}
finally
{
    Console.WriteLine("Gata");
}

Diferența importantă: throw; re-aruncă aceeași excepție cu stack trace-ul intact, deci vezi linia unde a apărut problema. throw ex; aruncă obiectul din nou, iar stack trace-ul începe de la linia din catch, astfel pierzi informația cea mai utilă la depanare. Dacă vrei să adaugi context, aruncă o excepție nouă cu cea originală ca InnerException: throw new ImportException("Import eșuat", ex);.

Filtrele when (C# 6+) permit prinderea condiționată fără a desface stiva. Bune practici: nu prinde Exception doar ca s-o ignori, nu folosi excepții pentru fluxul normal (de exemplu validare), prinde doar ce știi să tratezi.

Ce urmărește intervievatorul: Detaliul throw vs throw ex este întrebat foarte des. Se urmărește și dacă știi să nu înghiți excepțiile.

10 Junior

Ce afișează codul următor, cu o listă de struct-uri și o listă de clase?

Răspuns scurt: Afișează 0 pentru struct și 5 pentru clasă. Elementul din List de struct-uri este o copie, deci modificarea ei nu ajunge în listă; la clasă se modifică obiectul partajat.

C#
struct ContorS { public int Valoare; }
class ContorC { public int Valoare; }

var structuri = new List<ContorS> { new ContorS() };
var clase = new List<ContorC> { new ContorC() };

var s = structuri[0];
s.Valoare = 5;

var c = clase[0];
c.Valoare = 5;

Console.WriteLine(structuri[0].Valoare); // 0
Console.WriteLine(clase[0].Valoare);     // 5

Indexatorul List<T> este o proprietate care întoarce o copie a elementului. Pentru un struct, s este o copie independentă, deci modificarea nu afectează lista. Pentru o clasă, c este o copie a referinței, adică indică același obiect din listă.

Mai mult, scrierea directă structuri[0].Valoare = 5; nici nu compilează (eroarea CS1612), tocmai pentru că ai modifica o valoare temporară. Variantele corecte:

C#
var tmp = structuri[0];
tmp.Valoare = 5;
structuri[0] = tmp; // scrii copia înapoi

La un tablou (ContorS[]), tablou[0].Valoare = 5 funcționează, pentru că indexarea unui tablou dă acces direct la element, nu printr-o proprietate. Exemplul ilustrează de ce struct-urile mutabile sunt descurajate: comportamentul diferă subtil între tablouri, liste și proprietăți.

Ce urmărește intervievatorul: E o întrebare de tip „ce afișează” care verifică semantica de copiere. Mulți răspund 5 în ambele cazuri.

11 Mid

Ce sunt boxing și unboxing și de ce contează?

Răspuns scurt: Boxing înseamnă împachetarea unui tip valoare într-un obiect pe heap, când e tratat ca object sau ca interfață. Unboxing este extragerea valorii înapoi, cu cast explicit. Ambele costă alocări și timp.

Când un int este atribuit unei variabile object sau unei interfețe pe care o implementează (de exemplu IComparable), runtime-ul alocă un obiect pe heap și copiază valoarea în el. Asta e boxing. Operația inversă, (int)obj, verifică tipul și copiază valoarea înapoi: unboxing.

C#
int n = 42;
object o = n;      // boxing: alocare pe heap
int m = (int)o;    // unboxing
// long l = (long)o; // InvalidCastException: tipul din box este int

De ce contează:

  • fiecare boxing este o alocare, deci presiune pe garbage collector;
  • într-o buclă cu milioane de iterații diferența devine vizibilă;
  • unboxing-ul cere exact tipul original, altfel aruncă excepție.

Unde apare pe ascuns:

  • colecțiile vechi non-generice, ca ArrayList și Hashtable;
  • string.Format("{0}", n) sau concatenări cu object în versiuni mai vechi de .NET;
  • apelul unei metode de interfață pe un struct prin variabila de tip interfață;
  • Enum.HasFlag în .NET Framework (în .NET Core a fost optimizat).

Soluția principală au fost generics: List<int> stochează direct valori int, fără boxing, spre deosebire de ArrayList. Interpolarea de string-uri din C# 10 folosește handler-e care evită boxing-ul pentru tipurile valoare. Profilere precum dotMemory sau dotnet-counters arată numărul de alocări, util când cauți astfel de surse.

Ce urmărește intervievatorul: Testează înțelegerea costului ascuns al alocărilor și de ce generics au contat. Greșeala tipică e unboxing la alt tip numeric.

12 Mid

Ce este un record și prin ce diferă de o clasă obișnuită?

Răspuns scurt: Un record (C# 9+) este un tip pentru date, cu egalitate pe valori generată automat, ToString util, deconstrucție și copiere nedistructivă cu with. record class e tip referință, record struct (C# 10) e tip valoare.

Un record este gândit pentru obiecte care reprezintă date: DTO-uri, evenimente, valori de domeniu. Compilatorul generează pentru tine:

  • Equals, GetHashCode și == bazate pe valorile proprietăților, nu pe referință;
  • un ToString() care afișează proprietățile;
  • deconstrucție, pentru forma pozițională;
  • suport pentru expresia with, care creează o copie cu unele proprietăți schimbate.
C#
public record Produs(string Nume, decimal Pret);

var a = new Produs("Laptop", 4000m);
var b = new Produs("Laptop", 4000m);
Console.WriteLine(a == b);           // True
Console.WriteLine(ReferenceEquals(a, b)); // False

var redus = a with { Pret = 3500m };
Console.WriteLine(redus);            // Produs { Nume = Laptop, Pret = 3500 }
var (nume, pret) = redus;

Proprietățile din forma pozițională sunt init-only, deci obiectul este imutabil în mod implicit, ceea ce îl face sigur pentru chei de dicționar și pentru partajare între thread-uri.

Când nu e potrivit: pentru entități EF Core cu identitate (două comenzi cu aceleași câmpuri nu sunt aceeași comandă) și pentru obiecte cu stare care se schimbă des. Atenție și la egalitatea „superficială”: dacă un record conține o List<string>, se compară referințele listelor, nu conținutul lor. record struct (C# 10) combină aceste facilități cu semantica de tip valoare.

Ce urmărește intervievatorul: Verifică dacă știi C# modern și când alegi record. Capcana frecventă: egalitatea nu compară conținutul colecțiilor.

13 Mid

Ce sunt nullable reference types și ce problemă rezolvă?

Răspuns scurt: Nullable reference types (C# 8+) fac compilatorul să analizeze dacă o referință poate fi null. string înseamnă că nu se așteaptă null, string? că poate fi null, iar compilatorul dă avertismente la dereferențieri riscante.

NullReferenceException este probabil cea mai frecventă eroare în .NET. Cu nullable reference types activate (<Nullable>enable</Nullable> în fișierul .csproj, implicit în șabloanele noi începând cu .NET 6), declarația unui tip referință exprimă o intenție:

C#
public class Client
{
    public string Nume { get; set; } = "";   // nu ar trebui să fie null
    public string? Telefon { get; set; }     // poate lipsi
}

void Afiseaza(Client c)
{
    Console.WriteLine(c.Nume.Length);        // fără avertisment
    Console.WriteLine(c.Telefon.Length);     // avertisment CS8602
    if (c.Telefon is not null)
        Console.WriteLine(c.Telefon.Length); // OK, analiza știe că nu e null
}

Important: este o analiză statică, doar la compilare. La rulare, string și string? sunt același tip; nimic nu te împiedică să primești null dintr-o bibliotecă veche sau din deserializare. De aceea, la granițele aplicației (input de la utilizator, API-uri externe) tot trebuie să validezi.

Unelte utile:

  • operatorul ! (null-forgiving) spune compilatorului „știu eu că nu e null”; folosit des, anulează beneficiul;
  • atribute ca [NotNullWhen(true)] sau [MaybeNull] descriu contracte mai fine;
  • required (C# 11) obligă inițializarea unei proprietăți la creare.

Într-un proiect existent, activarea se face treptat, fișier cu fișier, cu #nullable enable, ca să nu fii copleșit de avertismente.

Ce urmărește intervievatorul: Se verifică dacă știi că verificarea e doar la compilare. Greșeala tipică: abuzul de operatorul ! ca să scapi de avertismente.

14 Mid

Cum folosești pattern matching și switch expressions în C# modern?

Răspuns scurt: Pattern matching permite testarea formei unei valori (tip, proprietăți, intervale) direct în is sau switch. Switch expressions (C# 8+) întorc o valoare și înlocuiesc lanțuri lungi de if-else într-un mod concis și verificat de compilator.

Pattern matching a evoluat de la C# 7 la C# 11 și acoperă mai multe forme:

  • type pattern: if (forma is Cerc c) testează tipul și declară variabila;
  • property pattern: comanda is { Status: Status.Platita, Total: > 1000 };
  • relational și logical patterns (C# 9): >= 18 and < 65, not null;
  • list patterns (C# 11): [1, 2, ..].
C#
public abstract record Forma;
public record Cerc(double Raza) : Forma;
public record Dreptunghi(double L, double H) : Forma;

static double Arie(Forma f) => f switch
{
    Cerc { Raza: <= 0 } => throw new ArgumentException("Rază invalidă"),
    Cerc c => Math.PI * c.Raza * c.Raza,
    Dreptunghi(var l, var h) => l * h,
    _ => throw new NotSupportedException()
};

static string Categorie(int varsta) => varsta switch
{
    < 0 => "invalid",
    < 18 => "minor",
    >= 18 and < 65 => "adult",
    _ => "senior"
};

Avantaje: codul e mai scurt, condițiile sunt evaluate în ordine, iar compilatorul avertizează când un switch pe un enum sau pe valori nu acoperă toate cazurile. Dacă niciun caz nu se potrivește și nu există _, se aruncă SwitchExpressionException la rulare.

Totuși, pentru comportament care variază după tip, polimorfismul (o metodă Arie() virtuală) rămâne adesea o alegere mai bună. Pattern matching strălucește când datele vin din afara ierarhiei tale sau când vrei logica într-un singur loc.

Ce urmărește intervievatorul: Verifică dacă ești la curent cu C# modern. Bonus dacă știi când e preferabil polimorfismul.

15 Mid

Ce sunt delegații, Func, Action și evenimentele?

Răspuns scurt: Un delegat este un tip care reprezintă o referință la o metodă cu o anumită semnătură. Func și Action sunt delegați generici predefiniți. Un event este un delegat încapsulat, pe care exteriorul doar se poate abona sau dezabona.

Un delegat descrie o semnătură de metodă și poate ține una sau mai multe metode compatibile (multicast). Lambda-urile din LINQ sunt, de fapt, delegați.

  • Action<T1, ...>: metodă care întoarce void;
  • Func<T1, ..., TResult>: metodă care întoarce TResult (ultimul parametru generic);
  • Predicate<T>: echivalent cu Func<T, bool>.
C#
Func<int, int, int> aduna = (a, b) => a + b;
Action<string> scrie = Console.WriteLine;
Console.WriteLine(aduna(2, 3)); // 5

public class Termostat
{
    public event EventHandler<double>? TemperaturaSchimbata;

    public void Seteaza(double t) =>
        TemperaturaSchimbata?.Invoke(this, t);
}

var termo = new Termostat();
termo.TemperaturaSchimbata += (s, t) => Console.WriteLine($"Nou: {t}");
termo.Seteaza(21.5);

De ce există event dacă avem delegați? Cu un câmp delegat public, orice cod extern ar putea face Delegat = null (ștergând toți abonații) sau l-ar putea invoca. Cuvântul event restricționează accesul din exterior la += și -=; doar clasa care îl declară îl poate declanșa.

Capcane:

  • un abonat care nu se dezabonează este ținut în viață de publisher, sursă clasică de memory leak;
  • invocarea unui event fără abonați aruncă NullReferenceException, de aceea se folosește ?.Invoke;
  • o excepție într-un abonat oprește apelarea celorlalți.

Ce urmărește intervievatorul: Testează înțelegerea callback-urilor și de ce event e mai sigur decât un delegat public. Leak-ul prin evenimente e un bonus apreciat.

OOP, interfețe și generics

16 Junior

Explică cele patru principii ale programării orientate pe obiecte, cu exemple în C#.

Răspuns scurt: Încapsularea ascunde starea internă în spatele unei interfețe publice, abstractizarea expune doar ce e esențial, moștenirea refolosește comportament dintr-o clasă de bază, iar polimorfismul permite tratarea uniformă a obiectelor de tipuri diferite.

  • Încapsularea: datele sunt private și se modifică doar prin metode care păstrează regulile obiectului. Un cont bancar nu expune un setter public pentru sold, ci metode Depune și Retrage care validează.
  • Abstractizarea: codul care folosește un obiect depinde de ce face acesta, nu de cum. O interfață INotificare cu metoda Trimite ascunde dacă e vorba de email sau SMS.
  • Moștenirea: o clasă derivată preia membrii clasei de bază și îi poate extinde. În C# există moștenire simplă de clase și implementare multiplă de interfețe.
  • Polimorfismul: același apel produce comportamente diferite în funcție de tipul real al obiectului, prin metode virtual/override sau prin interfețe.
C#
public class Cont
{
    public decimal Sold { get; private set; }

    public virtual void Retrage(decimal suma)
    {
        if (suma <= 0 || suma > Sold)
            throw new InvalidOperationException("Sumă invalidă");
        Sold -= suma;
    }
    public void Depune(decimal suma) => Sold += suma;
}

public class ContCuComision : Cont
{
    public override void Retrage(decimal suma) => base.Retrage(suma + 2m);
}

Cont c = new ContCuComision();
c.Depune(100);
c.Retrage(10); // se apelează versiunea cu comision

La interviu contează să dai exemple proprii și să arăți că știi și limitele: moștenirea creează cuplare puternică, așa că se folosește doar pentru relații reale de tip „este un”.

Ce urmărește intervievatorul: E o întrebare de deschidere. Intervievatorul vrea exemple concrete, nu definiții recitate.

17 Junior

Care este diferența dintre o interfață și o clasă abstractă?

Răspuns scurt: O interfață definește un contract pe care îl pot implementa mai multe clase, fără stare de instanță. O clasă abstractă poate avea câmpuri, constructori și cod comun, dar o clasă poate moșteni doar una.

Interfața spune „ce poate face” un tip. O clasă poate implementa oricâte interfețe, iar struct-urile pot implementa și ele interfețe. Interfețele nu au câmpuri de instanță și nici constructori.

Clasa abstractă spune „ce este” un tip și oferă o bază parțial implementată. Nu poate fi instanțiată, poate avea câmpuri, constructori, metode concrete și metode abstract pe care derivatele trebuie să le implementeze. O clasă poate moșteni o singură clasă.

C#
public interface IExportator
{
    string Extensie { get; }
    byte[] Exporta(IEnumerable<Raport> date);
}

public abstract class ExportatorBaza : IExportator
{
    protected readonly ILogger Logger;
    protected ExportatorBaza(ILogger logger) => Logger = logger;

    public abstract string Extensie { get; }
    public byte[] Exporta(IEnumerable<Raport> date)
    {
        Logger.LogInformation("Export {Ext}", Extensie);
        return Scrie(date);
    }
    protected abstract byte[] Scrie(IEnumerable<Raport> date);
}

Din C# 8 (.NET Core 3.0+), interfețele pot avea și default interface methods, adică implementări implicite, folosite mai ales ca să adaugi metode într-o interfață publică fără să strici implementările existente. Linia dintre cele două s-a subțiat, dar diferența de stare și de moștenire multiplă rămâne.

Regula practică: pornești de la interfețe pentru contracte și dependency injection, și adaugi o clasă abstractă doar când mai multe implementări chiar împart cod și stare.

Ce urmărește intervievatorul: Întrebare clasică. Se apreciază menționarea default interface methods și o regulă clară de alegere.

18 Junior

Ce fac virtual, override și new la metode?

Răspuns scurt: virtual permite unei metode să fie suprascrisă, override o suprascrie polimorfic, iar new ascunde metoda din bază fără polimorfism. Cu new, metoda apelată depinde de tipul declarat al variabilei, nu de tipul real.

În C#, metodele nu sunt virtuale implicit (spre deosebire de Java). Ca o derivată să poată schimba comportamentul, metoda din bază trebuie marcată virtual (sau abstract), iar derivata folosește override.

C#
class Animal
{
    public virtual string Sunet() => "...";
    public string Descriere() => "animal";
}

class Caine : Animal
{
    public override string Sunet() => "Ham";
    public new string Descriere() => "câine";
}

Animal a = new Caine();
Console.WriteLine(a.Sunet());      // Ham   (override: contează tipul real)
Console.WriteLine(a.Descriere());  // animal (new: contează tipul declarat)

Caine c = new Caine();
Console.WriteLine(c.Descriere());  // câine

Cu override, apelul trece prin tabela de metode virtuale și se alege implementarea tipului real. Cu new (method hiding) există două metode independente cu același nume; compilatorul o alege pe cea vizibilă din tipul declarat. Dacă omiți new, codul compilează cu avertismentul CS0108, dar comportamentul e același.

Alte detalii utile:

  • sealed override oprește suprascrierea mai departe în ierarhie;
  • base.Sunet() apelează implementarea din bază;
  • apelarea metodelor virtuale din constructor e riscantă: rulează override-ul derivatei înainte ca derivata să fie complet inițializată.

new se folosește rar, de obicei când o clasă de bază dintr-o bibliotecă adaugă un membru care intră în conflict cu unul de-al tău.

Ce urmărește intervievatorul: Exemplul cu new vs override este o capcană populară. Se verifică dacă înțelegi legarea la compilare față de cea la rulare.

19 Junior

Ce modificatori de acces există în C# și ce înseamnă fiecare?

Răspuns scurt: public (oriunde), private (doar în tip), protected (tip și derivate), internal (același assembly), protected internal (assembly sau derivate), private protected (derivate din același assembly). Membrii sunt implicit private, tipurile de nivel superior implicit internal.

Modificatorii controlează cine poate vedea un tip sau un membru, adică suprafața publică a codului tău:

  • public: accesibil de oriunde;
  • private: doar în interiorul tipului care îl declară; implicit pentru membrii claselor;
  • protected: în tip și în clasele derivate, chiar și din alte assembly-uri;
  • internal: oriunde în același assembly (proiect); implicit pentru clasele declarate direct în namespace;
  • protected internal: în același assembly sau în derivate din alte assembly-uri;
  • private protected (C# 7.2): doar în derivate care sunt și în același assembly;
  • file (C# 11): tipul e vizibil doar în fișierul sursă curent, util pentru generatoare de cod.
C#
public class Comanda
{
    private readonly List<Linie> _linii = new();
    public IReadOnlyList<Linie> Linii => _linii;
    internal void MarcheazaExportata() { /* folosit doar de modulul de export */ }
    protected virtual decimal CalculeazaTaxe() => 0m;
}

De ce contează: cu cât expui mai puțin, cu atât poți schimba mai ușor implementarea fără să strici codul altora. Regula bună este să pornești cu cel mai restrictiv nivel și să-l deschizi doar când e nevoie. internal e util în biblioteci pentru clase de infrastructură; dacă testele au nevoie de ele, atributul [assembly: InternalsVisibleTo("Proiect.Tests")] le face vizibile proiectului de test.

Ce urmărește intervievatorul: Se verifică cunoașterea valorilor implicite și a lui internal, care nu există în multe alte limbaje. Diferența protected internal vs private protected e un bonus.

20 Junior

Ce înseamnă o clasă static și o clasă sealed?

Răspuns scurt: O clasă static nu poate fi instanțiată și conține doar membri statici, cum ar fi metode utilitare. O clasă sealed poate fi instanțiată, dar nu poate fi moștenită.

static class: nu are instanțe, nu poate avea constructor de instanță, nu poate fi moștenită și conține doar membri statici. Se folosește pentru funcții utilitare fără stare (Math, File) și este obligatorie pentru metodele de extensie.

C#
public static class Validari
{
    public static bool EsteCnpValid(string cnp) =>
        cnp.Length == 13 && cnp.All(char.IsDigit);
}

sealed class: o clasă normală, care nu poate fi folosită ca bază. string este sealed. Motive pentru sealed:

  • intenția de design: clasa nu a fost gândită pentru extindere, iar moștenirea ar putea încălca invarianții ei;
  • performanță: JIT-ul poate devirtualiza apelurile pe tipuri sealed, iar verificările de tip sunt mai rapide; analizorul CA1852 din .NET 7 recomandă sigilarea tipurilor interne fără derivate.
C#
public sealed class TokenJwt
{
    public string Valoare { get; }
    public TokenJwt(string valoare) => Valoare = valoare;
}

Atenție la abuzul de clase statice: stare statică mutabilă (de exemplu un static List<> folosit ca cache) este partajată între toate request-urile unei aplicații web, nu e thread-safe implicit și îngreunează testarea, pentru că nu poate fi înlocuită cu un mock. Pentru servicii cu dependențe, alternativa este o clasă normală înregistrată ca singleton în dependency injection.

Ce urmărește intervievatorul: Verifică dacă știi motivele de design din spatele lor. Greșeala tipică: clase statice cu stare partajată în aplicații web.

21 Junior

Care este diferența dintre un câmp și o proprietate în C#?

Răspuns scurt: Un câmp este o variabilă stocată direct în obiect. O proprietate expune o valoare prin accesori get și set, care pot conține logică, validare sau acces restricționat, fără să schimbe sintaxa apelantului.

Un câmp (private int _varsta;) este stocarea propriu-zisă. O proprietate este, de fapt, o pereche de metode (get_Varsta, set_Varsta) cu sintaxa unei variabile. Convenția în .NET este ca datele publice să fie expuse doar prin proprietăți.

C#
public class Persoana
{
    private int _varsta;

    public int Varsta
    {
        get => _varsta;
        set => _varsta = value >= 0 ? value
            : throw new ArgumentOutOfRangeException(nameof(value));
    }

    public string Nume { get; set; } = "";       // auto-property
    public DateTime Creat { get; } = DateTime.UtcNow; // doar citire
    public string Cnp { get; init; } = "";       // setabil doar la inițializare
    public string NumeAfisat => $"{Nume} ({Varsta})"; // calculată
}

var p = new Persoana { Nume = "Ana", Varsta = 30, Cnp = "123" };
// p.Cnp = "456"; // eroare: init-only

De ce proprietăți și nu câmpuri publice:

  • poți adăuga validare sau logging mai târziu fără să schimbi API-ul;
  • poți avea accesori cu niveluri diferite (public get; private set;);
  • serializatoarele (System.Text.Json), data binding-ul și EF Core lucrează implicit cu proprietăți;
  • trecerea de la câmp la proprietate este o schimbare incompatibilă binar pentru codul compilat care o folosește.

init (C# 9) permite obiecte imutabile cu sintaxa de inițializare, iar required (C# 11) obligă apelantul să seteze proprietatea.

Ce urmărește intervievatorul: E o întrebare de bază despre încapsulare. Se apreciază menționarea init, required și a proprietăților calculate.

22 Junior

Ce sunt metodele de extensie și cum se scriu?

Răspuns scurt: O metodă de extensie este o metodă statică dintr-o clasă statică, al cărei prim parametru e marcat cu this. Se apelează ca și cum ar fi o metodă a tipului, fără să modifici sau să moștenești tipul.

Metodele de extensie îți permit să „adaugi” metode la tipuri pe care nu le controlezi (string, IEnumerable<T>, clase din biblioteci). Tot LINQ este construit așa: Where, Select și celelalte sunt metode de extensie pe IEnumerable<T>.

C#
public static class StringExtensions
{
    public static string Trunchiaza(this string text, int max) =>
        text.Length <= max ? text : text[..max] + "...";

    public static bool EsteGol(this string? text) =>
        string.IsNullOrWhiteSpace(text);
}

// utilizare, cu namespace-ul importat
string titlu = "Întrebări de interviu pentru .NET";
Console.WriteLine(titlu.Trunchiaza(10)); // Întrebări ...
string? x = null;
Console.WriteLine(x.EsteGol());          // True, fără NullReferenceException

Reguli și detalii:

  • clasa trebuie să fie static și negenerică, iar metoda static;
  • metoda e vizibilă doar dacă namespace-ul ei este importat cu using;
  • dacă tipul are deja o metodă de instanță cu aceeași semnătură, aceea câștigă, deci extensia e ignorată în tăcere;
  • extensiile nu au acces la membrii privați; e doar zahăr sintactic peste un apel static (StringExtensions.Trunchiaza(titlu, 10));
  • pot fi apelate pe null, cum arată exemplul, ceea ce poate surprinde.

În ASP.NET Core, metodele de extensie sunt folosite pentru a grupa înregistrările din dependency injection: builder.Services.AddModululMeu() face codul din Program.cs mult mai curat.

Ce urmărește intervievatorul: Verifică înțelegerea unui mecanism folosit peste tot în .NET. Bonus dacă știi regula de precedență față de metodele de instanță.

23 Mid

Ce sunt generics și la ce folosesc constrângerile where?

Răspuns scurt: Generics permit scrierea de clase și metode parametrizate după tip, sigure la compilare și fără boxing, cum ar fi List<T>. Constrângerile where restricționează T, de exemplu la clase, struct-uri, tipuri cu constructor fără parametri sau care implementează o interfață.

Fără generics, ai avea fie cod duplicat pentru fiecare tip, fie colecții de object cu cast-uri și boxing. Cu generics, tipul devine parametru, iar compilatorul verifică totul. Spre deosebire de Java, în .NET generics sunt păstrate la rulare (fără type erasure): List<int> și List<string> sunt tipuri distincte, iar pentru tipurile valoare JIT-ul generează cod specializat.

C#
public interface IEntitate { int Id { get; } }

public class Repository<T> where T : class, IEntitate
{
    private readonly Dictionary<int, T> _date = new();
    public void Adauga(T e) => _date[e.Id] = e;
    public T? Gaseste(int id) => _date.GetValueOrDefault(id);
}

public static T Maxim<T>(T a, T b) where T : IComparable<T> =>
    a.CompareTo(b) >= 0 ? a : b;

Console.WriteLine(Maxim(3, 7));         // 7
Console.WriteLine(Maxim("ana", "dan")); // dan

Constrângeri disponibile:

  • where T : class / struct / notnull / unmanaged;
  • where T : new() (constructor public fără parametri);
  • where T : BazaMea sau where T : IInterfata;
  • where T : U (T derivă din alt parametru generic).

Fără constrângeri, poți folosi pe T doar membrii din object. Constrângerea IComparable<T> e cea care permite apelul CompareTo. Din C# 11 (.NET 7), generic math permite constrângeri ca where T : INumber<T>, deci poți scrie o singură metodă Suma<T> pentru int, double și decimal.

Ce urmărește intervievatorul: Testează înțelegerea siguranței tipurilor și a constrângerilor. Diferența față de type erasure din Java e un plus.

24 Mid

Explică principiile SOLID cu exemple din proiecte .NET.

Răspuns scurt: SOLID înseamnă Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation și Dependency Inversion. Sunt reguli de design care fac codul mai ușor de modificat, testat și extins.

  • S, Single Responsibility: o clasă are un singur motiv să se schimbe. Un ComandaService care calculează prețul, trimite email și generează PDF ar trebui spart în servicii separate.
  • O, Open/Closed: deschis pentru extindere, închis pentru modificare. Adaugi o nouă metodă de plată implementând IProcesatorPlata, nu adăugând încă un case într-un switch uriaș.
  • L, Liskov Substitution: o derivată trebuie să poată înlocui baza fără surprize. Dacă ReadOnlyRepository : Repository aruncă NotSupportedException la Save, principiul e încălcat.
  • I, Interface Segregation: interfețe mici și focalizate. Mai bine ICitireProduse și IScriereProduse decât un IProdusService cu 30 de metode pe care fiecare client le folosește parțial.
  • D, Dependency Inversion: modulele de nivel înalt depind de abstracții, nu de implementări concrete.
C#
public interface IEmailSender { Task TrimiteAsync(string catre, string text); }

public class InregistrareService
{
    private readonly IEmailSender _email;
    public InregistrareService(IEmailSender email) => _email = email;

    public Task InregistreazaAsync(string email) =>
        _email.TrimiteAsync(email, "Bun venit!");
}

Aici InregistrareService nu știe dacă emailul pleacă prin SMTP, SendGrid sau un fake din teste; containerul DI din ASP.NET Core injectează implementarea. Principiile nu sunt scopuri în sine: aplicate mecanic, produc zeci de interfețe cu o singură implementare. La interviu, arată un exemplu în care aplicarea unui principiu a rezolvat o problemă reală.

Ce urmărește intervievatorul: Se verifică dacă poți lega teoria de cod real. Greșeala tipică e recitarea acronimului fără exemple.

25 Senior

Ce înseamnă covarianța și contravarianța în generics (in și out)?

Răspuns scurt: Covarianța (out T) permite folosirea unui tip mai derivat decât cel declarat, de exemplu IEnumerable<string> ca IEnumerable<object>. Contravarianța (in T) permite un tip mai general, de exemplu Action<object> ca Action<string>.

Implicit, tipurile generice sunt invariante: o List<string> nu este o List<object>. Dacă ar fi, ai putea face listaObject.Add(42) într-o listă de string-uri. Variația este permisă doar pe interfețe și delegați, și doar când e sigură.

  • Covarianță, out T: T apare doar în poziții de ieșire (valori returnate). IEnumerable<out T> doar produce elemente, deci un IEnumerable<string> poate fi tratat ca IEnumerable<object>.
  • Contravarianță, in T: T apare doar ca parametru de intrare. Un IComparer<object> poate compara orice, deci poate fi folosit ca IComparer<string>.
C#
IEnumerable<string> nume = new List<string> { "Ana", "Dan" };
IEnumerable<object> obiecte = nume;      // OK, covarianță

Action<object> logheaza = o => Console.WriteLine(o);
Action<string> logString = logheaza;     // OK, contravarianță

// List<object> l = new List<string>();  // eroare: List<T> e invariantă

public interface IProducator<out T> { T Produ(); }
public interface IConsumator<in T> { void Consuma(T item); }

Compilatorul verifică regulile: dacă declari out T și încerci să folosești T ca parametru, primești eroare. Variația funcționează doar pentru tipuri referință: IEnumerable<int> nu poate deveni IEnumerable<object>, pentru că ar necesita boxing. Tablourile sunt covariante din motive istorice (object[] a = new string[1]; a[0] = 1; compilează, dar aruncă ArrayTypeMismatchException), o greșeală de design pe care generics au evitat-o.

Ce urmărește intervievatorul: Întrebare de senior care verifică înțelegerea profundă a sistemului de tipuri. Exemplul cu tablourile covariante e foarte apreciat.

26 Senior

De ce se spune „composition over inheritance”? Dă un exemplu în care ai înlocui moștenirea cu compunerea.

Răspuns scurt: Moștenirea leagă strâns derivata de detaliile bazei și fixează comportamentul la compilare. Compunerea, adică un obiect care deleagă către alte obiecte injectate prin interfețe, permite combinarea și schimbarea comportamentelor fără ierarhii adânci și fragile.

Moștenirea pare atractivă pentru refolosirea codului, dar aduce probleme pe termen lung:

  • fragile base class: o schimbare în bază poate strica derivate la care nu te gândeai;
  • explozia combinațiilor: RaportPdf, RaportPdfCriptat, RaportExcelCriptat, RaportExcelCriptatArhivat... fiecare variație nouă dublează numărul de clase;
  • C# are moștenire simplă, deci o clasă nu poate prelua comportament din două baze.

Cu compunerea, fiecare aspect devine un obiect separat, iar clasa principală le combină:

C#
public interface IFormat { byte[] Genereaza(Raport r); }
public interface IPostProcesare { byte[] Aplica(byte[] date); }

public sealed class GeneratorRaport
{
    private readonly IFormat _format;
    private readonly IEnumerable<IPostProcesare> _pasi;

    public GeneratorRaport(IFormat format, IEnumerable<IPostProcesare> pasi)
        => (_format, _pasi) = (format, pasi);

    public byte[] Genereaza(Raport r) =>
        _pasi.Aggregate(_format.Genereaza(r), (date, pas) => pas.Aplica(date));
}

Acum orice combinație (PDF criptat și arhivat, Excel doar arhivat) se obține din configurare, nu din clase noi. Este, de fapt, aplicarea pattern-urilor Strategy și Decorator. Testarea devine și ea mai simplă: fiecare piesă se testează izolat, iar GeneratorRaport primește fake-uri.

Moștenirea rămâne potrivită pentru relații stabile „este un” și pentru puncte de extensie gândite explicit (de exemplu ControllerBase sau DbContext). Cheia la interviu este să arăți că alegi conștient, în funcție de cât de des se schimbă variațiile.

Ce urmărește intervievatorul: Se urmărește maturitatea în design și cunoașterea pattern-urilor Strategy și Decorator. Răspunsul slab este „moștenirea e rea”.

Colecții și LINQ

27 Junior

Când folosești List<T>, un tablou, Dictionary<TKey, TValue> sau HashSet<T>?

Răspuns scurt: Tabloul are dimensiune fixă, List<T> crește dinamic, Dictionary oferă căutare după cheie în timp mediu constant, iar HashSet<T> ține elemente unice cu verificare rapidă a apartenenței. Alegerea depinde de operația cea mai frecventă.

  • T[] (tablou): dimensiune fixă, acces după index O(1), cel mai mic overhead. Bun când știi numărul de elemente sau pentru buffere.
  • List<T>: tablou intern care se redimensionează (de obicei dublând capacitatea). Acces după index O(1), Add la final O(1) amortizat, dar Contains, IndexOf și Remove sunt O(n), iar Insert(0, x) mută toate elementele.
  • Dictionary<TKey, TValue>: tabelă hash. Căutare, adăugare și ștergere după cheie în O(1) mediu. Cheile trebuie să aibă GetHashCode și Equals corecte.
  • HashSet<T>: ca un dicționar fără valori. Ideal pentru „am mai văzut elementul ăsta?” și pentru operații de mulțimi (UnionWith, IntersectWith).
C#
var emailuri = new List<string> { "a@x.ro", "b@x.ro", "A@x.ro" };

// O(n) la fiecare verificare: lent pentru liste mari
bool exista = emailuri.Contains("b@x.ro");

var unice = new HashSet<string>(emailuri, StringComparer.OrdinalIgnoreCase);
Console.WriteLine(unice.Count);               // 2

var clientiDupaId = clienti.ToDictionary(c => c.Id);
if (clientiDupaId.TryGetValue(42, out var client))
    Console.WriteLine(client.Nume);

O greșeală frecventă de performanță: o buclă care apelează list.Contains sau list.FirstOrDefault(x => x.Id == id) pentru fiecare element dintr-o altă listă, adică O(n·m). Construirea unui Dictionary sau HashSet o dată transformă totul în O(n + m). Alte colecții utile: Queue<T>, Stack<T>, SortedDictionary, LinkedList<T> (rar folosită în practică).

Ce urmărește intervievatorul: Verifică gândirea despre complexitate. Bonus pentru comparatorul StringComparer și exemplul de buclă O(n·m).

28 Junior

Ce este LINQ și care e diferența dintre query syntax și method syntax?

Răspuns scurt: LINQ (Language Integrated Query) este un set de operatori pentru interogarea colecțiilor, bazelor de date și altor surse cu aceeași sintaxă. Query syntax seamănă cu SQL, method syntax folosește metode de extensie și lambda; compilatorul transformă prima în a doua.

LINQ aduce operații de filtrare, proiecție, sortare și grupare direct în C#, tipizate și verificate la compilare. Funcționează peste IEnumerable<T> (obiecte în memorie, LINQ to Objects) și peste IQueryable<T> (de exemplu EF Core, care traduce expresia în SQL).

C#
var produse = new List<Produs>
{
    new("Laptop", "IT", 4200m), new("Mouse", "IT", 90m), new("Cafea", "Alimente", 45m)
};

// query syntax
var q1 = from p in produse
         where p.Pret > 50
         orderby p.Pret descending
         select p.Nume;

// method syntax (echivalent)
var q2 = produse
    .Where(p => p.Pret > 50)
    .OrderByDescending(p => p.Pret)
    .Select(p => p.Nume);

Console.WriteLine(string.Join(", ", q2)); // Laptop, Mouse

record Produs(string Nume, string Categorie, decimal Pret);

Query syntax este doar zahăr sintactic: compilatorul îl rescrie în apeluri Where, OrderByDescending, Select. Diferențe practice:

  • unii operatori (Count, First, Distinct, Take, Any) există doar ca metode;
  • query syntax e mai lizibilă la join-uri și la let (variabile intermediare);
  • în majoritatea echipelor se folosește method syntax.

Ce trebuie știut dincolo de sintaxă: majoritatea operatorilor sunt evaluați leneș (deferred execution), iar pe IQueryable lambda-urile devin arbori de expresii traduși în SQL, deci nu poți folosi orice metodă C# acolo.

Ce urmărește intervievatorul: Întrebare de bază. Se verifică dacă știi că cele două sintaxe sunt echivalente și unde se aplică LINQ.

29 Junior

Ce afișează codul următor și ce este deferred execution?

Răspuns scurt: Afișează 3, nu 2, pentru că Where nu se execută la declarare, ci la enumerare. Deferred execution înseamnă că interogarea LINQ este doar o rețetă, evaluată de fiecare dată când este parcursă.

C#
var numere = new List<int> { 1, 5, 10 };
var mari = numere.Where(n => n > 3);   // nu se execută nimic încă

numere.Add(20);

Console.WriteLine(mari.Count());       // 3 (5, 10, 20)

Where, Select, OrderBy, Skip, Take și mulți alți operatori întorc un obiect care descrie operația. Filtrarea are loc abia când cineva enumeră rezultatul: foreach, Count(), ToList(), First(). În momentul Count(), lista conține deja 20, deci rezultatul e 3.

Operatorii care forțează execuția imediată (materializează) sunt ToList, ToArray, ToDictionary, Count, Sum, First, Any și alții care întorc o singură valoare sau o colecție concretă.

C#
var instantaneu = numere.Where(n => n > 3).ToList(); // evaluat acum
numere.Add(30);
Console.WriteLine(instantaneu.Count); // tot 3

Consecințe practice:

  • o interogare poate fi evaluată de mai multe ori, cu costul repetat (problema enumerării multiple);
  • excepțiile din lambda apar la enumerare, nu la declarare, ceea ce poate deruta la depanare;
  • dacă lambda captează o variabilă, se folosește valoarea ei din momentul enumerării;
  • în EF Core, interogarea ajunge la baza de date doar la materializare, ceea ce permite compunerea condițiilor înainte.

Evaluarea leneșă permite și lucrul cu secvențe foarte mari sau infinite, pentru că elementele sunt procesate unul câte unul.

Ce urmărește intervievatorul: Întrebare clasică de tip „ce afișează”. Mulți candidați răspund 2 sau nu știu ce operatori materializează.

30 Junior

Care este diferența dintre First, FirstOrDefault, Single și SingleOrDefault?

Răspuns scurt: First întoarce primul element și aruncă excepție dacă nu există niciunul; FirstOrDefault întoarce default. Single cere exact un element și aruncă dacă sunt zero sau mai multe; SingleOrDefault aruncă doar dacă sunt mai multe.

Cele patru se comportă astfel:

  • First(): aruncă InvalidOperationException la 0 elemente; altfel întoarce primul;
  • FirstOrDefault(): întoarce default(T) (null pentru clase, 0 pentru int) la 0 elemente;
  • Single(): aruncă la 0 și la mai multe elemente;
  • SingleOrDefault(): întoarce default la 0, aruncă la mai multe.
C#
var clienti = new List<Client> { new(1, "Ana"), new(2, "Dan"), new(3, "Ana") };

var a = clienti.First(c => c.Nume == "Ana");            // Id 1
var b = clienti.FirstOrDefault(c => c.Nume == "Ion");   // null
var d = clienti.Single(c => c.Id == 2);                 // Dan
// clienti.Single(c => c.Nume == "Ana");                // aruncă: două potriviri

record Client(int Id, string Nume);

Cum alegi: Single exprimă o regulă de business („după ID trebuie să existe exact unul”) și te ajută să descoperi date corupte, de exemplu duplicate neașteptate. First spune „orice prim element îmi convine”, de obicei împreună cu o sortare explicită.

Detalii care contează:

  • Single trebuie să parcurgă și restul ca să verifice unicitatea; în EF Core se traduce cu TOP(2), iar First cu TOP(1);
  • FirstOrDefault pe tipuri valoare poate ascunde lipsa (un 0 arată ca o valoare validă); din .NET 6 există suprascrierea FirstOrDefault(predicat, valoareImplicita);
  • în EF Core, pentru căutare după cheie primară există și Find, care verifică întâi entitățile deja încărcate în context.

Ce urmărește intervievatorul: Se verifică atenția la cazurile limită și dacă știi să exprimi intenția. Greșeala tipică: FirstOrDefault urmat de dereferențiere fără verificare.

31 Junior

Care este diferența dintre Select și SelectMany?

Răspuns scurt: Select transformă fiecare element într-o valoare, păstrând un rezultat per element. SelectMany transformă fiecare element într-o colecție și apoi aplatizează toate colecțiile într-o singură secvență.

Select este o proiecție unu-la-unu: din N elemente obții N rezultate. Dacă proiecția întoarce o colecție, rezultatul este o colecție de colecții. SelectMany aplatizează: concatenează colecțiile interioare într-o singură secvență.

C#
var comenzi = new List<Comanda>
{
    new(1, new() { "Laptop", "Mouse" }),
    new(2, new() { "Monitor" })
};

IEnumerable<List<string>> imbricat = comenzi.Select(c => c.Produse);
// [[Laptop, Mouse], [Monitor]]

IEnumerable<string> plat = comenzi.SelectMany(c => c.Produse);
// [Laptop, Mouse, Monitor]

var perechi = comenzi.SelectMany(
    c => c.Produse,
    (c, produs) => $"{c.Id}: {produs}");
// ["1: Laptop", "1: Mouse", "2: Monitor"]

record Comanda(int Id, List<string> Produse);

A doua suprascriere a lui SelectMany, cu un selector de rezultat, îți permite să păstrezi legătura cu elementul părinte, ca în ultimul exemplu. În query syntax, două clauze from consecutive se traduc în SelectMany:

C#
var toate = from c in comenzi
            from p in c.Produse
            select new { c.Id, Produs = p };

Cazuri tipice de utilizare: toate rolurile tuturor utilizatorilor, toate liniile tuturor facturilor, toate cuvintele din mai multe propoziții. În EF Core, SelectMany pe o navigare de tip colecție se traduce de obicei într-un JOIN (sau CROSS APPLY în SQL Server).

Ce urmărește intervievatorul: Testează înțelegerea proiecțiilor și a structurilor imbricate. Mulți candidați nu cunosc a doua suprascriere.

32 Mid

Care este diferența dintre IEnumerable<T> și IQueryable<T>?

Răspuns scurt: IEnumerable<T> execută operatorii LINQ în memorie, cu delegați C#. IQueryable<T> construiește un arbore de expresii pe care un provider, de exemplu EF Core, îl traduce în SQL și îl execută la sursă.

Ambele sunt evaluate leneș, dar diferă unde se face munca.

  • IEnumerable<T>: operatorii primesc Func<T, bool>, adică cod compilat, executat în procesul tău pe obiecte deja încărcate.
  • IQueryable<T>: operatorii primesc Expression<Func<T, bool>>, o structură de date care descrie lambda. Provider-ul o analizează și o transformă în altceva, de obicei SQL.
C#
// IQueryable: filtrarea și TOP se fac în SQL Server
var scumpe = await db.Produse
    .Where(p => p.Pret > 1000)
    .OrderBy(p => p.Nume)
    .Take(10)
    .ToListAsync();

// capcana: AsEnumerable() mută restul în memorie
var gresit = db.Produse
    .AsEnumerable()
    .Where(p => p.Pret > 1000)  // aduce TOATE produsele din tabel
    .Take(10)
    .ToList();

În al doilea exemplu, totul după AsEnumerable() rulează în C#, deci baza de date întoarce întreg tabelul. Aceeași problemă apare când o metodă de repository întoarce IEnumerable<T> în loc de IQueryable<T> și apelantul adaugă filtre.

Pe de altă parte, cu IQueryable nu poți folosi orice cod C# în lambda: o metodă proprie ca EsteValid(p) nu poate fi tradusă, iar EF Core (din versiunea 3.0) aruncă excepție în loc să evalueze în tăcere pe client. Soluțiile sunt rescrierea condiției în termeni traductibili sau materializarea conștientă a unui set mic de date. Unele echipe preferă să nu expună IQueryable în afara stratului de date, ca să controleze ce interogări ajung la bază.

Ce urmărește intervievatorul: Este una dintre cele mai importante întrebări .NET cu bază de date. Se verifică dacă știi unde se execută filtrarea.

33 Mid

Cum folosești GroupBy, ToDictionary și ToLookup? Care e diferența dintre ultimele două?

Răspuns scurt: GroupBy grupează elementele după o cheie, cu evaluare leneșă. ToDictionary creează imediat un dicționar cu o valoare per cheie și aruncă la chei duplicate. ToLookup creează imediat o structură cheie la mai multe valori, care întoarce secvență goală pentru chei inexistente.

C#
var vanzari = new List<Vanzare>
{
    new("Cluj", 100m), new("Iași", 50m), new("Cluj", 70m)
};

var totaluri = vanzari
    .GroupBy(v => v.Oras)
    .Select(g => new { Oras = g.Key, Total = g.Sum(v => v.Suma), Nr = g.Count() });
// Cluj 170 2, Iași 50 1

var dict = totaluri.ToDictionary(t => t.Oras, t => t.Total);
Console.WriteLine(dict["Cluj"]);               // 170

// vanzari.ToDictionary(v => v.Oras);          // ArgumentException: cheie duplicată

ILookup<string, Vanzare> dupaOras = vanzari.ToLookup(v => v.Oras);
Console.WriteLine(dupaOras["Cluj"].Count());   // 2
Console.WriteLine(dupaOras["Brașov"].Count()); // 0, fără excepție

record Vanzare(string Oras, decimal Suma);

Diferențe esențiale:

  • GroupBy este leneș și se reevaluează la fiecare parcurgere; ToLookup îl materializează o dată;
  • Dictionary cere chei unice și aruncă KeyNotFoundException pentru chei lipsă; ILookup permite mai multe valori per cheie și întoarce secvență goală;
  • ILookup este imutabil, Dictionary poate fi modificat.

În EF Core, GroupBy urmat de agregări (Count, Sum, Max) se traduce în GROUP BY în SQL. În schimb, cererea grupurilor întregi, cu toate elementele, nu se traducea în versiunile mai vechi și dădea excepție; suportul a fost extins treptat în versiunile recente. Regula sigură: în interogări către bază, după GroupBy proiectează agregări, nu colecții.

Ce urmărește intervievatorul: Se verifică dacă știi să agregi date și diferența practică ToDictionary/ToLookup. Excepția la chei duplicate prinde mulți candidați.

34 Mid

Ce face yield return și cum funcționează un iterator?

Răspuns scurt: yield return transformă o metodă într-un iterator: compilatorul generează o mașină de stări care produce elementele pe rând, la cerere. Execuția se oprește după fiecare yield și continuă de acolo la următorul MoveNext.

O metodă care întoarce IEnumerable<T> și folosește yield return nu se execută la apel. Compilatorul generează o clasă care implementează IEnumerable<T> și IEnumerator<T>, iar corpul metodei rulează bucată cu bucată, la fiecare MoveNext().

C#
static IEnumerable<int> Numere()
{
    Console.WriteLine("start");
    yield return 1;
    Console.WriteLine("după 1");
    yield return 2;
    Console.WriteLine("final");
}

var seq = Numere();           // nu afișează nimic
foreach (var n in seq.Take(1))
    Console.WriteLine(n);
// start
// 1

Codul de după primul yield nu rulează niciodată, pentru că Take(1) oprește enumerarea. yield break termină secvența explicit.

Când e util:

  • secvențe mari sau infinite (citirea unui fișier linie cu linie, paginarea unui API);
  • pipeline-uri de procesare care nu țin tot în memorie;
  • implementarea simplă a propriilor operatori LINQ.

Capcane:

  • validarea argumentelor dintr-un iterator se execută abia la enumerare. Soluția: o metodă publică ce validează imediat și apelează o funcție locală iterator;
  • fiecare enumerare rulează metoda de la capăt;
  • try/finally funcționează (finally rulează la Dispose al enumeratorului, pe care foreach îl apelează), dar yield return nu poate fi pus într-un bloc try care are catch.

Pentru surse asincrone există IAsyncEnumerable<T> (C# 8), cu yield return în metode async și consum prin await foreach.

Ce urmărește intervievatorul: Testează înțelegerea evaluării leneșe la nivel de mecanism. Capcana validării întârziate este un bonus.

35 Mid

Ce problemă apare la enumerarea multiplă a unui IEnumerable și cum o eviți?

Răspuns scurt: Fiecare parcurgere a unui IEnumerable leneș reexecută întreaga interogare: alte apeluri la baza de date, recalculări sau chiar rezultate diferite. Soluția este materializarea o singură dată cu ToList sau ToArray când ai nevoie de mai multe parcurgeri.

C#
IEnumerable<Client> activi = db.Clienti.Where(c => c.Activ); // IQueryable tratat ca IEnumerable

if (activi.Any())                                  // query 1
{
    Console.WriteLine(activi.Count());             // query 2
    foreach (var c in activi)                      // query 3
        Console.WriteLine(c.Nume);
}

Codul trimite trei interogări la baza de date. Între ele, datele se pot schimba, deci Count poate spune 5 iar foreach poate afișa 6 clienți. Aceeași problemă apare cu iteratorii yield, cu un Select care face calcule scumpe sau apeluri HTTP, ori cu secvențe care pot fi citite o singură dată (un stream de rețea).

Varianta corectă:

C#
var activi = await db.Clienti.Where(c => c.Activ).ToListAsync(); // o singură interogare
if (activi.Count > 0)
{
    Console.WriteLine(activi.Count);
    foreach (var c in activi) Console.WriteLine(c.Nume);
}

Recomandări:

  • dacă o metodă are nevoie să parcurgă de mai multe ori, cere IReadOnlyCollection<T> sau IReadOnlyList<T> în semnătură; asta face contractul explicit;
  • dacă primești IEnumerable<T>, materializează o dată la începutul metodei;
  • Rider și ReSharper semnalează „Possible multiple enumeration”, iar regula de analiză CA1851 din .NET 7 face același lucru.

Nu materializa orbește tot: pentru o singură parcurgere a unei secvențe mari, evaluarea leneșă economisește memorie.

Ce urmărește intervievatorul: Verifică dacă înțelegi consecințele deferred execution în cod real. Exemplul cu trei interogări la bază e cel pe care îl caută intervievatorul.

36 Mid

Scrie o funcție care primește un text și întoarce cele mai frecvente 3 cuvinte, cu numărul de apariții.

Răspuns scurt: Normalizezi textul (litere mici, separare după caractere care nu sunt litere), grupezi după cuvânt, numeri, sortezi descrescător după frecvență și alfabetic la egalitate, apoi iei primele trei. Cu LINQ, totul încape în câteva linii.

C#
using System.Text.RegularExpressions;

static IReadOnlyList<(string Cuvant, int Nr)> TopCuvinte(string text, int n = 3)
{
    if (string.IsNullOrWhiteSpace(text)) return Array.Empty<(string, int)>();

    return Regex.Matches(text.ToLowerInvariant(), @"\p{L}+")
        .Select(m => m.Value)
        .GroupBy(c => c)
        .Select(g => (Cuvant: g.Key, Nr: g.Count()))
        .OrderByDescending(x => x.Nr)
        .ThenBy(x => x.Cuvant, StringComparer.Ordinal)
        .Take(n)
        .ToList();
}

foreach (var (c, nr) in TopCuvinte("Ana are mere. Ana are pere, iar Dan are mere."))
    Console.WriteLine($"{c}: {nr}");
// are: 3
// ana: 2
// mere: 2

Decizii pe care merită să le explici la interviu:

  • \p{L}+ potrivește secvențe de litere Unicode, deci păstrează diacriticele; un Split(' ') simplu ar lăsa punctuația lipită de cuvinte;
  • ThenBy face rezultatul determinist când frecvențele sunt egale;
  • complexitatea: O(n) pentru numărare și O(k log k) pentru sortarea celor k cuvinte distincte.

Dacă intervievatorul cere o variantă fără LINQ sau mai performantă, folosești un Dictionary<string, int> pentru numărare, apoi un PriorityQueue<string, int> (din .NET 6) de dimensiune n, care dă O(k log n) la selecție. Merită să întrebi întâi despre cerințe: contează majusculele? se exclud cuvintele de legătură? textul are câțiva gigaocteți și trebuie citit în flux?

Ce urmărește intervievatorul: E o problemă de live coding. Se urmărește claritatea, cazurile limită și dacă îți pui întrebări despre cerințe.

Async/await și concurență

37 Junior

Ce sunt async și await și de ce le folosim?

Răspuns scurt: async marchează o metodă care poate folosi await, iar await suspendă metoda până se termină un Task, fără să blocheze thread-ul. Astfel, thread-ul poate servi alte cereri sau poate menține interfața responsivă cât timp așteptăm I/O.

Multe operații dintr-o aplicație reală așteaptă după altceva: baza de date, un API extern, discul. Cu cod sincron, thread-ul stă blocat în tot acest timp. Într-un server ASP.NET Core, thread-urile blocate înseamnă mai puține cereri servite simultan; într-o aplicație desktop, înseamnă o fereastră înghețată.

C#
public async Task<Produs?> GetProdusAsync(int id)
{
    var json = await _http.GetStringAsync($"https://api.exemplu.ro/produse/{id}");
    return JsonSerializer.Deserialize<Produs>(json);
}

Ce se întâmplă la await:

  • dacă task-ul e deja terminat, codul continuă sincron;
  • altfel, metoda întoarce imediat un Task neterminat apelantului, iar thread-ul este eliberat;
  • când operația I/O se termină, restul metodei (continuarea) este programat să ruleze, de obicei pe un thread din thread pool.

Important: async nu creează thread-uri noi și nu face codul mai rapid. Pentru o operație I/O, de cele mai multe ori nu există niciun thread care „așteaptă”; sistemul de operare anunță finalizarea. Beneficiul este scalabilitatea și responsivitatea.

Convenții: metodele asincrone se termină în Async, întorc Task sau Task<T>, iar asincronia se propagă în sus („async all the way”). Pentru muncă intensă pe CPU, async nu ajută direct; acolo se folosește Task.Run sau paralelism, iar în ASP.NET Core nici atât, pentru că cererea rulează deja pe un thread din pool.

Ce urmărește intervievatorul: Verifică dacă înțelegi că async înseamnă eliberarea thread-ului, nu paralelism. Greșeala clasică: „await pornește un thread nou”.

38 Junior

De ce ar trebui să eviți async void?

Răspuns scurt: O metodă async void nu poate fi așteptată, deci apelantul nu știe când s-a terminat, iar excepțiile ei nu pot fi prinse cu try/catch de apelant și pot opri procesul. Se folosește doar pentru event handlere.

O metodă async Task întoarce un obiect prin care apelantul poate aștepta finalizarea și poate observa excepțiile. O metodă async void nu întoarce nimic, așa că:

  • nu poate fi așteptată: apelantul continuă imediat, iar ordinea operațiilor devine imprevizibilă;
  • excepțiile scapă: o excepție dintr-o metodă async void este aruncată pe contextul de sincronizare activ sau pe thread pool; nu o poți prinde din exterior și, de regulă, oprește procesul;
  • nu poate fi testată ușor, pentru că testul nu are după ce aștepta.
C#
async void SalveazaGresit()
{
    await Task.Delay(100);
    throw new InvalidOperationException("boom");
}

try
{
    SalveazaGresit();   // try/catch NU prinde excepția
}
catch (Exception) { Console.WriteLine("nu ajunge aici"); }

async Task SalveazaCorect()
{
    await Task.Delay(100);
    throw new InvalidOperationException("boom");
}

try { await SalveazaCorect(); }
catch (InvalidOperationException) { Console.WriteLine("prinsă"); }

Singura utilizare legitimă este pentru event handlere (de exemplu button.Click += async (s, e) => ... în WinForms, WPF sau MAUI), unde semnătura este impusă de delegat. Chiar și acolo, pune un try/catch în interiorul handlerului.

O capcană mai subtilă: o lambda async transmisă unui parametru de tip Action devine async void. De exemplu, lista.ForEach(async x => await ProceseazaAsync(x)) nu așteaptă nimic. Varianta corectă este un foreach cu await sau Task.WhenAll.

Ce urmărește intervievatorul: E o capcană foarte frecventă în cod real. Exemplul cu List.ForEach și lambda async este un bonus apreciat.

39 Junior

Care este diferența dintre un Thread și un Task?

Răspuns scurt: Un Thread este un fir de execuție al sistemului de operare, scump de creat. Un Task reprezintă o operație care se va termina în viitor, poate rula pe thread pool sau poate să nu folosească niciun thread, ca la I/O asincron.

Un Thread este o resursă de nivel scăzut: are propriul stack (de obicei în jur de 1 MB rezervat), costă la creare și la schimbarea de context. Îl controlezi direct (pornire, prioritate, fundal sau prim-plan), dar nu întoarce un rezultat și nu are un mecanism natural de propagare a excepțiilor.

Un Task este o abstracție de nivel înalt: o promisiune că o operație se va termina, cu un rezultat (Task<T>) sau cu o excepție. Un task poate fi:

  • muncă pe CPU programată pe thread pool cu Task.Run, care refolosește un număr limitat de thread-uri;
  • o operație I/O asincronă (citire de rețea), care nu ține ocupat niciun thread în timpul așteptării;
  • un task deja terminat (Task.FromResult).
C#
// thread manual: rar necesar
var t = new Thread(() => Console.WriteLine("pe thread dedicat"));
t.Start();
t.Join();

// task pe thread pool, cu rezultat și excepții propagate
long suma = await Task.Run(() => Enumerable.Range(1, 1_000_000).Sum(x => (long)x));

// task I/O: nu consumă thread cât așteaptă
string html = await httpClient.GetStringAsync("https://example.com");

Task-urile se compun ușor (WhenAll, WhenAny, continuări), suportă anulare prin CancellationToken și se integrează cu async/await. În cod modern, crearea directă de Thread este rară: doar pentru fire de lungă durată cu cerințe speciale. Pentru muncă de fundal în ASP.NET Core există BackgroundService (implementare de IHostedService), care gestionează corect pornirea și oprirea.

Ce urmărește intervievatorul: Verifică dacă înțelegi abstracția Task și thread pool-ul. Greșeala tipică: „Task e un thread mai ușor”.

40 Mid

De ce poate apărea un deadlock când apelezi .Result sau .Wait() pe un Task?

Răspuns scurt: Când blochezi un thread care deține un context de sincronizare (UI sau ASP.NET clasic) și task-ul vrea să-și continue execuția pe același context, fiecare îl așteaptă pe celălalt. Soluția este await peste tot, nu blocarea sincronă.

Scenariul clasic, într-o aplicație WPF, WinForms sau ASP.NET pe .NET Framework:

C#
// handler de buton, pe thread-ul UI
void Buton_Click(object s, EventArgs e)
{
    var date = IncarcaAsync().Result; // blochează thread-ul UI
    eticheta.Text = date;
}

async Task<string> IncarcaAsync()
{
    await Task.Delay(1000);   // continuarea vrea să revină pe thread-ul UI
    return "gata";
}

Pașii: .Result blochează thread-ul UI până se termină task-ul. await a capturat SynchronizationContext-ul UI, deci după o secundă continuarea trebuie să ruleze pe thread-ul UI. Dar acesta e blocat, așteptând task-ul. Nimeni nu avansează: deadlock.

În ASP.NET Core nu există SynchronizationContext, deci acest deadlock specific nu apare. Totuși, .Result rămâne o problemă: blochează un thread din pool pe durata operației, iar sub încărcare poate duce la thread pool starvation, cu latențe uriașe și timeout-uri.

Soluții, în ordinea preferinței:

  • „async all the way”: transformă apelantul în async și folosește await;
  • în biblioteci, ConfigureAwait(false) reduce riscul, dar nu e o soluție completă;
  • dacă ești forțat să rămâi sincron, GetAwaiter().GetResult() măcar aruncă excepția originală în loc de AggregateException, dar nu elimină blocarea.

Din C# 7.1 Main poate fi async, iar în ASP.NET Core acțiunile, filtrele și middleware-ul suportă nativ async, deci rareori ai un motiv real pentru .Result.

Ce urmărește intervievatorul: Testează înțelegerea contextului de sincronizare. Diferența dintre UI sau ASP.NET clasic și ASP.NET Core separă un răspuns înțeles de unul memorat.

41 Mid

Cum rulezi mai multe operații asincrone în paralel? Care e diferența dintre await succesiv și Task.WhenAll?

Răspuns scurt: Cu await succesiv, fiecare operație începe după ce s-a terminat precedenta, deci timpii se adună. Dacă pornești toate task-urile întâi și apoi aștepți cu Task.WhenAll, ele rulează concurent, iar timpul total e aproximativ cel al celei mai lente.

C#
// secvențial: aproximativ 1 + 1 + 1 = 3 secunde
var a = await GetClientAsync(id);
var b = await GetComenziAsync(id);
var c = await GetFacturiAsync(id);

// concurent: aproximativ 1 secundă
var tClient = GetClientAsync(id);
var tComenzi = GetComenziAsync(id);
var tFacturi = GetFacturiAsync(id);
await Task.WhenAll(tClient, tComenzi, tFacturi);

var client = await tClient;     // deja terminat, nu mai așteaptă
var comenzi = await tComenzi;

Un task pornește în momentul în care apelezi metoda async, nu când faci await. De aceea, apelarea tuturor metodelor înainte de primul await le lasă să ruleze concurent.

Detalii importante:

  • dacă unul sau mai multe task-uri eșuează, await Task.WhenAll aruncă prima excepție; toate sunt disponibile în Exception.InnerExceptions al task-ului întors de WhenAll;
  • Task.WhenAny întoarce primul task terminat, util pentru timeout-uri sau pentru „cel mai rapid răspuns”;
  • nu poți rula în paralel interogări pe același DbContext din EF Core; primești InvalidOperationException, pentru că un context nu suportă operații concurente. Fiecare task are nevoie de propriul context, de exemplu prin IDbContextFactory;
  • pentru sute de operații, nu porni totul deodată: limitează concurența cu SemaphoreSlim sau, din .NET 6, cu Parallel.ForEachAsync și MaxDegreeOfParallelism, ca să nu suprasoliciți serviciul apelat.

Ce urmărește intervievatorul: Se verifică dacă știi când pornește un task și limitele concurenței. Capcana cu DbContext partajat este foarte des întâlnită.

42 Mid

Ce este un CancellationToken și cum îl folosești corect?

Răspuns scurt: CancellationToken este mecanismul cooperativ din .NET prin care un apelant cere oprirea unei operații. Metoda primește token-ul, îl transmite mai departe către apelurile I/O și verifică periodic dacă s-a cerut anularea.

Anularea în .NET este cooperativă: nimeni nu oprește forțat un thread. Un CancellationTokenSource emite cererea (Cancel() sau un timeout), iar codul care primește CancellationToken decide cum reacționează.

C#
app.MapGet("/raport", async (IRaportService svc, CancellationToken ct) =>
    Results.Ok(await svc.GenereazaAsync(ct)));

public async Task<Raport> GenereazaAsync(CancellationToken ct)
{
    var date = await _db.Vanzari.ToListAsync(ct);    // transmis mai departe

    foreach (var lot in date.Chunk(1000))
    {
        ct.ThrowIfCancellationRequested();           // verificare în bucle CPU
        Proceseaza(lot);
    }
    return new Raport();
}

using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
await svc.GenereazaAsync(cts.Token);  // anulat automat după 5 secunde

În ASP.NET Core, un parametru CancellationToken într-o acțiune sau într-un minimal API este legat automat de HttpContext.RequestAborted: dacă utilizatorul închide pagina, interogarea SQL în curs este anulată și nu mai consumă resurse.

Bune practici:

  • pune CancellationToken ca ultim parametru, cu = default în biblioteci;
  • transmite-l la toate apelurile asincrone care îl acceptă;
  • la anulare se aruncă OperationCanceledException (sau derivata TaskCanceledException); nu o loga ca eroare, e un comportament normal;
  • CancellationTokenSource.CreateLinkedTokenSource combină mai multe surse, de exemplu anularea cererii plus un timeout propriu;
  • CancellationTokenSource implementează IDisposable, important mai ales când are timer.

Ce urmărește intervievatorul: Verifică dacă scrii cod care respectă resursele serverului. Mulți candidați primesc token-ul și uită să-l transmită mai departe.

43 Senior

Ce face ConfigureAwait(false) și când are sens să-l folosești?

Răspuns scurt: ConfigureAwait(false) spune că continuarea de după await nu trebuie să revină pe contextul de sincronizare capturat. Are sens în biblioteci reutilizabile; în ASP.NET Core nu există un astfel de context, deci efectul practic e minim.

Implicit, await capturează contextul curent (SynchronizationContext sau, dacă nu există, TaskScheduler-ul curent) și programează continuarea pe el. Pe thread-ul UI asta e exact ce vrei, pentru că după await poți actualiza controalele. Într-o bibliotecă, însă, nu ai nevoie de context, iar revenirea pe el costă și poate provoca deadlock-uri dacă apelantul blochează sincron.

C#
// cod de bibliotecă (pachet NuGet, client reutilizabil)
public async Task<Config> CitesteAsync(string cale)
{
    using var stream = File.OpenRead(cale);
    var cfg = await JsonSerializer.DeserializeAsync<Config>(stream)
        .ConfigureAwait(false);
    return cfg!;
}

// cod UI: fără ConfigureAwait(false), ca să revii pe thread-ul UI
private async void Incarca_Click(object s, EventArgs e)
{
    var cfg = await _servicii.CitesteAsync("config.json");
    eticheta.Text = cfg.Nume; // necesită thread-ul UI
}

Ghidul general:

  • cod de bibliotecă: folosește ConfigureAwait(false) la fiecare await, pentru că nu știi în ce tip de aplicație va rula;
  • aplicații UI: nu-l folosi acolo unde atingi interfața după await;
  • ASP.NET Core: nu există SynchronizationContext, deci nu e necesar în codul aplicației; multe echipe îl omit pentru lizibilitate.

Detaliu des greșit: ConfigureAwait(false) afectează doar await-ul pe care e aplicat. Dacă task-ul era deja terminat, continuarea rulează sincron pe contextul curent, deci nu garantează mutarea de pe thread-ul UI. Din .NET 8 există și ConfigureAwaitOptions pentru control mai fin. Nu este remediul pentru deadlock-uri cauzate de .Result; remediul corect rămâne await.

Ce urmărește intervievatorul: Întrebare de senior despre contexte de execuție. Se verifică nuanța ASP.NET Core vs UI vs bibliotecă, nu o regulă aplicată orbește.

44 Senior

Ce este o race condition și cum protejezi datele partajate între thread-uri în .NET?

Răspuns scurt: O race condition apare când rezultatul depinde de ordinea în care thread-urile accesează date comune. Te protejezi cu lock pentru secțiuni critice, Interlocked pentru operații atomice simple, colecții concurente sau, cel mai bine, evitând starea mutabilă partajată.

C#
int contor = 0;
Parallel.For(0, 100_000, _ => contor++);
Console.WriteLine(contor); // de obicei mai puțin de 100000

contor++ înseamnă citire, adunare și scriere. Două thread-uri pot citi aceeași valoare, iar o incrementare se pierde. Soluții, de la simplu la specializat:

C#
// operație atomică pe o singură variabilă
Parallel.For(0, 100_000, _ => Interlocked.Increment(ref contor));

// secțiune critică pentru mai multe câmpuri care trebuie să rămână coerente
private readonly object _sync = new();
public void Transfera(decimal suma)
{
    lock (_sync)
    {
        _sursa -= suma;
        _destinatie += suma;
    }
}

// colecție thread-safe
var cache = new ConcurrentDictionary<int, Produs>();
var p = cache.GetOrAdd(id, cheie => IncarcaProdus(cheie));

Reguli importante:

  • lock pe un obiect privat dedicat, niciodată pe this, pe un string sau pe un Type;
  • nu poți face await în interiorul unui lock (eroare de compilare); pentru cod asincron folosești SemaphoreSlim(1, 1) cu await WaitAsync() și Release() în finally;
  • deadlock-urile apar când două thread-uri iau aceleași lock-uri în ordine diferită; impune o ordine fixă;
  • ConcurrentDictionary.GetOrAdd poate apela fabrica de mai multe ori la concurență; doar rezultatul stocat e unic;
  • din .NET 9 există tipul System.Threading.Lock, mai eficient decât un object simplu.

În aplicațiile web, cea mai bună protecție e designul: servicii fără stare, date imutabile și starea ținută în baza de date, cu tranzacții.

Ce urmărește intervievatorul: Testează înțelegerea concurenței și a instrumentelor potrivite fiecărui caz. Greșeala frecventă: await în lock sau lock pe this.

45 Senior

Ce generează compilatorul pentru o metodă async? Explică mașina de stări.

Răspuns scurt: Compilatorul rescrie metoda async într-un tip care implementează IAsyncStateMachine. Fiecare await devine o stare; la un task neterminat, mașina își salvează starea și variabilele locale, se înregistrează ca continuare și revine, apoi MoveNext reia execuția de unde a rămas.

Pentru o metodă ca:

C#
public async Task<int> CalculeazaAsync()
{
    int a = await PrimaAsync();
    int b = await ADouaAsync(a);
    return a + b;
}

compilatorul generează, simplificat:

  • un struct (în build-urile Release) <CalculeazaAsync>d__0 : IAsyncStateMachine, cu câmpuri pentru variabilele locale (a, b), pentru starea curentă și pentru awaiter-ele în curs;
  • un AsyncTaskMethodBuilder<int> care creează și completează Task<int>-ul întors apelantului;
  • metoda MoveNext(), care conține corpul original împărțit după fiecare await.

Fluxul la un await:

  • se apelează GetAwaiter() pe task și se verifică IsCompleted;
  • dacă e deja terminat, se continuă sincron, fără alocări suplimentare;
  • dacă nu, se salvează starea, iar builder-ul apelează AwaitUnsafeOnCompleted, care înregistrează MoveNext drept continuare; abia acum mașina de stări este mutată pe heap;
  • când task-ul se termină, MoveNext este reapelat, sare la eticheta stării salvate, citește rezultatul cu GetResult() și continuă.

Excepțiile din corp sunt prinse de un try/catch generat și puse pe task cu SetException, de aceea apar abia la await. Implicații practice: o metodă async are un cost mic, dar real, deci pentru metode care doar transmit un task mai departe (return _repo.GetAsync(id);) poți renunța la async/await. Atenție însă: astfel metoda dispare din stack trace, iar un using sau try din ea s-ar încheia înainte de terminarea task-ului.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului, nu doar a sintaxei. Partea despre când merită eliminat async arată experiență reală.

46 Senior

Ce este ValueTask și când îl folosești în locul lui Task?

Răspuns scurt: ValueTask<T> este un struct care poate conține direct un rezultat sincron sau un task, evitând alocarea unui obiect Task pe căile rapide. Merită pentru metode foarte des apelate care se termină de obicei sincron, de exemplu citirea dintr-un cache.

Task<T> este o clasă, deci o metodă async care întoarce o valoare nouă alocă de regulă un obiect pe heap (runtime-ul cache-uiește doar câteva cazuri, cum ar fi Task<bool> terminat). Pentru majoritatea codului, costul e neglijabil. Pentru o metodă apelată de milioane de ori, care de obicei găsește rezultatul imediat, alocările se adună.

C#
private readonly ConcurrentDictionary<int, Produs> _cache = new();

public ValueTask<Produs> GetAsync(int id)
{
    if (_cache.TryGetValue(id, out var p))
        return ValueTask.FromResult(p);          // fără alocare

    return new ValueTask<Produs>(IncarcaSiCacheazaAsync(id));
}

private async Task<Produs> IncarcaSiCacheazaAsync(int id)
{
    var p = await _repo.GetAsync(id);
    _cache[id] = p;
    return p;
}

ValueTask vine cu restricții stricte, pentru că poate fi susținut de obiecte refolosite (IValueTaskSource):

  • îl aștepți o singură dată; nu-l aștepta de două ori și nu-l stoca pentru mai târziu;
  • nu-l aștepta concurent din mai multe locuri;
  • nu folosi .Result înainte să fie terminat;
  • dacă ai nevoie de oricare dintre acestea, convertește-l cu .AsTask().

Exemple din .NET: Stream.ReadAsync(Memory<byte>), IAsyncEnumerator<T>.MoveNextAsync, ChannelReader<T>.ReadAsync. Recomandarea echipei .NET: folosește implicit Task; treci la ValueTask doar când măsurătorile arată că alocările contează și când calea sincronă este cea dominantă.

Ce urmărește intervievatorul: Se verifică înțelegerea compromisurilor de performanță și a restricțiilor de utilizare. Răspunsul slab: „ValueTask e mereu mai rapid”.

CLR, memorie și garbage collector

47 Junior

Ce sunt CLR, IL și JIT? Care e diferența dintre .NET Framework și .NET modern?

Răspuns scurt: Codul C# este compilat în IL (Intermediate Language), iar CLR (Common Language Runtime) îl execută, compilându-l în cod nativ cu JIT în momentul rulării. .NET Framework este varianta veche, doar pentru Windows; .NET (Core, apoi .NET 5+) este cross-platform și open source.

Pașii de la cod la execuție:

  • compilatorul C# (Roslyn) transformă codul în IL, un set de instrucțiuni independent de procesor, plus metadate, într-un assembly (.dll);
  • la rulare, CLR încarcă assembly-ul, verifică tipurile și gestionează memoria (garbage collector), excepțiile și thread-urile;
  • JIT (Just-In-Time compiler) compilează fiecare metodă în cod nativ la primul apel. Din .NET Core 3.0 există tiered compilation: întâi o compilare rapidă, apoi, pentru metodele folosite des, o recompilare optimizată.
BASH
dotnet new console -n Demo
cd Demo
dotnet build      # produce bin/Debug/net8.0/Demo.dll cu IL
dotnet run

IL-ul poate fi inspectat cu unelte precum ILSpy sau site-ul SharpLab, util ca să vezi ce generează compilatorul pentru async, foreach sau lambda-uri.

Despre platforme:

  • .NET Framework (ultima versiune 4.8.1): doar Windows, încă întâlnit în aplicații enterprise mai vechi (ASP.NET MVC 5, WCF, WebForms);
  • .NET Core 1.0 până la 3.1, apoi .NET 5, 6, 7, 8, 9...: cross-platform (Windows, Linux, macOS), open source, cu performanță mult mai bună; versiunile pare (6, 8, 10) sunt LTS, cu suport extins;
  • .NET Standard a fost o specificație de API comun pentru biblioteci care trebuiau să ruleze pe ambele.

La interviu merită să spui cu ce versiune ai lucrat; migrarea de pe .NET Framework pe .NET modern este un subiect frecvent în proiectele reale.

Ce urmărește intervievatorul: Întrebare de bază despre platformă. Se apreciază cunoașterea tiered compilation și a diferenței dintre versiunile LTS și cele cu suport scurt.

48 Junior

Ce este garbage collector-ul și cum decide ce memorie eliberează?

Răspuns scurt: Garbage collector-ul (GC) eliberează automat memoria obiectelor de pe heap la care nu mai ajunge nicio referință din rădăcini: variabile locale active, câmpuri statice, registre. Nu trebuie să eliberezi manual memoria, dar trebuie să eliberezi resursele negestionate.

În C# creezi obiecte cu new, dar nu le ștergi niciodată explicit. GC-ul rulează când o generație se umple, la presiune de memorie sau la GC.Collect() (care aproape niciodată nu trebuie apelat manual) și face următoarele:

  • marcare: pornește de la rădăcini (GC roots): variabile locale și parametri din metodele active, câmpuri static, handle-uri GC, registre CPU; urmează toate referințele și marchează obiectele accesibile;
  • curățare: tot ce nu a fost marcat e considerat gunoi;
  • compactare: mută obiectele vii unul lângă altul, ca alocările viitoare să fie rapide (doar un pointer incrementat) și memoria să nu fie fragmentată.
C#
void Proceseaza()
{
    var buffer = new byte[1024]; // obiect pe heap, rădăcină: variabila locală
    Foloseste(buffer);
}   // după ieșire nu mai există referințe: buffer devine eligibil pentru colectare

Consecințe importante:

  • două obiecte care se referă unul pe altul, dar la care nu ajunge nimic din rădăcini, sunt colectate; ciclurile nu sunt o problemă, spre deosebire de reference counting;
  • momentul colectării nu e determinist;
  • GC-ul gestionează doar memoria gestionată; fișierele, conexiunile la baza de date și socket-urile trebuie închise explicit prin IDisposable și using;
  • un obiect încă referit, de exemplu dintr-o listă statică sau de un event, nu va fi colectat niciodată: așa apar memory leak-urile în .NET.

În timpul unor faze ale colectării, thread-urile aplicației sunt oprite, de aceea alocările inutile în codul executat foarte des afectează latența.

Ce urmărește intervievatorul: Verifică dacă înțelegi rădăcinile și limitele GC-ului. Greșeala tipică: credința că GC închide și conexiunile la baza de date.

49 Mid

Explică generațiile garbage collector-ului și Large Object Heap.

Răspuns scurt: Heap-ul gestionat are trei generații: Gen 0 pentru obiecte noi, Gen 1 ca zonă tampon, Gen 2 pentru obiecte longevive. Obiectele de cel puțin 85.000 de octeți merg direct în Large Object Heap, colectat odată cu Gen 2 și necompactat implicit.

GC-ul .NET se bazează pe ipoteza generațională: majoritatea obiectelor mor tinere (obiecte temporare dintr-un request, string-uri intermediare), iar cele care supraviețuiesc tind să trăiască mult (cache-uri, singleton-uri).

  • Gen 0: aici sunt alocate obiectele noi. Se colectează des și rapid, pentru că e mică.
  • Gen 1: obiectele care au supraviețuit unei colectări Gen 0. Buffer între obiectele scurte și cele lungi.
  • Gen 2: obiectele care au supraviețuit și Gen 1. Colectarea completă e cea mai scumpă.

O colectare de Gen N colectează și toate generațiile mai mici. Ideea e să cureți des zona unde e cel mai mult gunoi, fără să parcurgi tot heap-ul.

Large Object Heap (LOH): obiectele de 85.000 de octeți sau mai mari (de obicei tablouri mari) sunt alocate separat. LOH-ul e colectat logic împreună cu Gen 2 și, implicit, nu este compactat, pentru că mutarea unor blocuri mari e scumpă. Efectul: fragmentare și colectări Gen 2 costisitoare dacă aloci des buffere mari temporare.

C#
// alocare repetată pe LOH: presiune mare pe Gen 2
var buffer = new byte[1_000_000];

// alternativă: închiriere dintr-un pool reutilizabil
var pool = ArrayPool<byte>.Shared;
byte[] buf = pool.Rent(1_000_000);
try { /* folosește buf */ }
finally { pool.Return(buf); }

Pentru diagnostic: dotnet-counters monitor arată numărul de colectări pe generație, iar dotnet-gcdump sau un profiler arată ce ocupă memoria. Există și moduri de GC: Workstation și Server (implicit în ASP.NET Core, cu câte un heap per nucleu), plus colectare concurentă în fundal pentru Gen 2.

Ce urmărește intervievatorul: Testează înțelegerea costurilor reale ale alocărilor. Bonus pentru ArrayPool și pentru uneltele de diagnostic.

50 Mid

Ce este IDisposable, cum funcționează using și ce rol are un finalizer?

Răspuns scurt: IDisposable expune metoda Dispose pentru eliberarea deterministă a resurselor negestionate: fișiere, conexiuni, socket-uri. using garantează apelul Dispose la ieșirea din bloc. Un finalizer este o plasă de siguranță rulată de GC, nedeterministă și costisitoare.

GC-ul eliberează memoria, dar nu știe când trebuie închisă o conexiune la baza de date sau un fișier. Pentru asta există IDisposable.

C#
// using declaration (C# 8): Dispose la finalul blocului curent
using var conexiune = new SqlConnection(connString);
await conexiune.OpenAsync();

// using statement clasic
using (var writer = new StreamWriter("log.txt"))
{
    writer.WriteLine("salut");
} // writer.Dispose() aici, chiar și la excepție

// varianta asincronă pentru IAsyncDisposable
await using var stream = File.OpenWrite("date.bin");

using este transformat de compilator într-un try/finally care apelează Dispose(), deci resursa se eliberează chiar dacă apare o excepție.

Un finalizer (~ClasaMea()) este apelat de GC înainte de colectarea obiectului, pe un thread separat, la un moment imprevizibil. Obiectele cu finalizer supraviețuiesc cel puțin o colectare în plus, deci costă. Ai nevoie de finalizer doar dacă ții direct un handle nativ; în cod modern se folosește SafeHandle, care îl gestionează pentru tine.

Pattern-ul Dispose simplificat pentru o clasă care ține alte resurse gestionate:

C#
public sealed class ExportService : IDisposable
{
    private readonly FileStream _fisier = File.Create("export.csv");
    private bool _disposed;

    public void Dispose()
    {
        if (_disposed) return;
        _fisier.Dispose();
        _disposed = true;
    }
}

În ASP.NET Core, containerul DI apelează Dispose automat pentru serviciile pe care le-a creat, la finalul scope-ului. Excepție celebră: HttpClient nu ar trebui creat și distrus per request; se folosește IHttpClientFactory, ca să eviți epuizarea socket-urilor.

Ce urmărește intervievatorul: Verifică diferența dintre memorie și resurse și dacă știi cum se folosește using în practică. Cazul HttpClient este un bonus frecvent cerut.

51 Mid

Unde sunt alocate în memorie tipurile valoare și tipurile referință? Este corect că „struct-urile stau pe stack”?

Răspuns scurt: Obiectele tipurilor referință stau pe heap-ul gestionat. Tipurile valoare stau acolo unde e declarată variabila: pe stack ca variabile locale, dar în interiorul obiectului pe heap când sunt câmpuri ale unei clase, elemente de tablou sau variabile capturate.

Afirmația „struct-urile stau pe stack” e o simplificare care devine greșită în multe cazuri. Regula corectă: un tip valoare este stocat inline, acolo unde trăiește variabila care îl conține.

  • variabilă locală sau parametru: de obicei pe stack (sau chiar doar în registre CPU);
  • câmp într-o clasă: pe heap, în interiorul obiectului clasei;
  • element într-un tablou Punct[]: pe heap, în blocul tabloului;
  • variabilă locală capturată de o lambda sau folosită după un await: mutată de compilator într-un obiect pe heap (closure sau mașină de stări);
  • convertit în object sau interfață: copiat într-o „cutie” pe heap (boxing).
C#
struct Punct { public int X, Y; }

class Forma
{
    public Punct Centru;       // stă pe heap, în obiectul Forma
}

void Metoda()
{
    Punct p = new Punct();     // local: stack
    var puncte = new Punct[1000]; // un singur bloc pe heap cu 1000 de struct-uri inline
    Func<int> f = () => p.X;   // p e capturat: compilatorul îl mută într-o clasă pe heap
}

Pentru tipurile referință, variabila (referința) urmează aceleași reguli, dar obiectul propriu-zis este mereu pe heap. Stack-ul fiecărui thread este mic (de regulă în jur de 1 MB) și se eliberează automat la ieșirea din metodă, fără GC.

De ce contează la interviu: arată că înțelegi că diferența esențială este semantica (copiere vs partajare), nu locația. Locația devine importantă la optimizare, unde ref struct (de exemplu Span<T>) garantează că tipul nu ajunge niciodată pe heap.

Ce urmărește intervievatorul: Întrebare-capcană pentru a vedea dacă înțelegi nuanța, nu doar mitul. Exemplul cu captura în lambda impresionează.

52 Senior

Cum poate apărea un memory leak într-o aplicație .NET, deși există garbage collector? Cum l-ai investiga?

Răspuns scurt: Leak-urile apar când obiecte nefolositoare rămân referite din rădăcini: evenimente nedezabonate, cache-uri statice fără limită, singleton-uri care țin servicii scoped, timere. Le investighezi urmărind memoria în timp și comparând dump-uri de heap pentru a vedea ce crește și cine ține referința.

GC-ul nu colectează nimic la care se ajunge din rădăcini. Un leak .NET este, aproape întotdeauna, o referință uitată. Cauze frecvente:

  • evenimente: un obiect cu viață scurtă se abonează la un event al unui obiect cu viață lungă și nu se dezabonează; publisher-ul îl ține în viață;
  • cache-uri statice (static Dictionary) care doar cresc; soluția e IMemoryCache cu expirare și SizeLimit;
  • captive dependency: un singleton care ține un serviciu scoped, de exemplu un DbContext care acumulează entități urmărite;
  • timere și task-uri de fundal care captează obiecte în lambda;
  • resurse negestionate nedispuse, de exemplu HttpClient creat per cerere, care epuizează socket-urile chiar dacă memoria pare în regulă.
C#
public class Ecran
{
    public Ecran(ServiciuGlobal s) => s.DateNoi += Actualizeaza; // fără -= : leak
    private void Actualizeaza(object? o, EventArgs e) { }
}

Investigația, pas cu pas:

  • confirmi trendul: dotnet-counters monitor -p <pid> arată GC Heap Size și numărul de colectări Gen 2; dacă memoria crește constant și după colectări complete, ai un leak;
  • iei două dump-uri la distanță de timp: dotnet-gcdump collect -p <pid> sau dotnet-dump collect;
  • le compari în Visual Studio, PerfView sau dotMemory: ce tipuri au crescut ca număr de instanțe;
  • pentru tipul suspect, cauți calea către rădăcină (gcroot în dotnet-dump analyze), care arată exact cine ține referința.

Odată găsită cauza, scrie un test sau o alertă de monitorizare, ca problema să nu revină neobservată.

Ce urmărește intervievatorul: Testează experiența practică de diagnostic în producție. Se apreciază unelte concrete și o metodologie, nu doar lista de cauze.

53 Senior

Ce sunt Span<T> și Memory<T> și ce probleme rezolvă?

Răspuns scurt: Span<T> este o fereastră tipizată și sigură peste o zonă contiguă de memorie (tablou, stack, memorie nativă), care permite tăierea și procesarea fără copiere și fără alocări. Fiind ref struct, trăiește doar pe stack; Memory<T> poate fi stocat și folosit în cod async.

Multe operații pe text și pe date binare alocă inutil: Substring, Split, ToArray, copieri de buffere. Span<T> (din .NET Core 2.1) oferă acces la o porțiune de memorie fără să o copieze.

C#
// fără alocări: parsare a unei date din "2026-10-31"
static (int An, int Luna, int Zi) Parseaza(ReadOnlySpan<char> s) =>
    (int.Parse(s[..4]), int.Parse(s.Slice(5, 2)), int.Parse(s[8..]));

var data = Parseaza("2026-10-31");

// buffer temporar pe stack, fără heap
Span<byte> buffer = stackalloc byte[256];
int scrisi = Encoding.UTF8.GetBytes("salut", buffer);

Cu string.Substring, fiecare bucată ar fi fost un string nou pe heap. Cu ReadOnlySpan<char>, s[..4] este doar un pointer plus o lungime.

Restricțiile lui Span<T> vin din faptul că este ref struct: nu poate fi câmp într-o clasă, nu poate fi boxed, nu poate fi capturat de lambda și nu poate trăi peste un await (în versiunile mai vechi de C# nici nu putea fi variabilă locală într-o metodă async; C# 13 relaxează parțial regula, cât timp nu traversează un await). Aceste reguli garantează că nu va referi niciodată memorie de pe un stack care nu mai există.

Memory<T> este un struct obișnuit care poate fi stocat în câmpuri și transmis prin cod asincron; când ai nevoie să procesezi, obții un Span prin .Span. API-uri ca Stream.ReadAsync(Memory<byte>) și PipeReader din System.IO.Pipelines folosesc acest model.

În aplicații obișnuite rar scrii Span direct, dar beneficiezi indirect: Kestrel, System.Text.Json și parserele din .NET sunt construite pe el. Îl folosești când profilerul arată alocări mari în cod executat foarte des.

Ce urmărește intervievatorul: Întrebare de senior despre performanță. Se verifică înțelegerea restricțiilor ref struct și motivul lor, nu doar „e mai rapid”.

54 Senior

Ce opțiuni ai pentru pornire mai rapidă și consum redus în .NET: tiered compilation, ReadyToRun și Native AOT?

Răspuns scurt: Tiered compilation compilează rapid la pornire și optimizează ulterior metodele folosite des. ReadyToRun include cod precompilat în assembly-uri, păstrând JIT-ul. Native AOT (din .NET 7) produce un executabil nativ fără JIT, cu pornire foarte rapidă, dar cu limitări la reflection și generare dinamică de cod.

În mod implicit, fiecare metodă e compilată de JIT la primul apel, ceea ce costă la pornire. .NET oferă trei pârghii:

  • Tiered compilation (implicită din .NET Core 3.0): tier 0 compilează rapid, fără optimizări; metodele apelate des sunt recompilate în tier 1, optimizat. Din .NET 8, Dynamic PGO este activ implicit: JIT-ul folosește date colectate la rulare (de exemplu tipurile reale de la apeluri virtuale) ca să optimizeze mai bine.
  • ReadyToRun (R2R): la publicare, assembly-urile conțin și cod nativ precompilat; JIT-ul rămâne disponibil pentru restul și pentru reoptimizare. Pornire mai rapidă, fișiere mai mari.
  • Native AOT: întreaga aplicație este compilată înainte de rulare într-un executabil nativ, fără JIT și fără să ai nevoie de runtime instalat. Pornire de ordinul milisecundelor și memorie mai mică, util pentru funcții serverless, containere mici și unelte CLI.
BASH
dotnet publish -c Release -r linux-x64 -p:PublishReadyToRun=true
dotnet publish -c Release -r linux-x64 -p:PublishAot=true

Limitările Native AOT:

  • reflection dinamică, Assembly.LoadFrom și generarea de cod la rulare (Reflection.Emit) nu funcționează sau sunt limitate;
  • bibliotecile trebuie să fie compatibile cu „trimming”; System.Text.Json cere source generators (JsonSerializerContext);
  • în ASP.NET Core, suportul (din .NET 8) acoperă minimal APIs, nu și MVC complet; EF Core are suport doar parțial și experimental în versiunile recente.

Alegerea depinde de profil: pentru un API care rulează continuu, JIT-ul cu PGO poate da chiar throughput mai bun pe termen lung; pentru procese scurte, AOT câștigă.

Ce urmărește intervievatorul: Testează cunoașterea opțiunilor moderne de deployment și a compromisurilor. Răspunsul bun menționează explicit limitările AOT.

ASP.NET Core și dependency injection

55 Junior

Ce este ASP.NET Core și ce rol are Kestrel?

Răspuns scurt: ASP.NET Core este framework-ul cross-platform din .NET pentru aplicații web: API-uri REST, MVC, Razor Pages, Blazor, SignalR, gRPC. Kestrel este serverul web inclus, care ascultă cererile HTTP și le trimite prin pipeline-ul aplicației.

ASP.NET Core a fost rescris de la zero față de ASP.NET clasic: modular, open source, rulează pe Windows, Linux și macOS și nu mai depinde de IIS. O aplicație este un proces .NET obișnuit, pornit cu dotnet MyApi.dll.

C#
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();

var app = builder.Build();
app.MapControllers();
app.MapGet("/health", () => Results.Ok("ok"));
app.Run();

Componentele principale:

  • host-ul (WebApplication), care încarcă configurarea, logging-ul și containerul de dependency injection;
  • Kestrel, serverul HTTP cross-platform, foarte performant, care suportă HTTP/1.1, HTTP/2 și HTTP/3;
  • pipeline-ul de middleware, prin care trece fiecare cerere;
  • endpoint-urile: controllere, minimal APIs, Razor Pages, hub-uri SignalR, servicii gRPC.

Kestrel poate fi expus direct pe internet, dar în producție se pune adesea în spatele unui reverse proxy (Nginx, IIS, YARP, un load balancer din cloud) care se ocupă de TLS, compresie, limitare și echilibrarea încărcării. Pe Windows, aplicația poate rula și în IIS prin ASP.NET Core Module (in-process sau out-of-process). Când pui un proxy în față, configurezi UseForwardedHeaders, ca aplicația să vadă IP-ul real al clientului și schema https.

Pentru interviu e util să știi ce versiune folosești și diferența față de ASP.NET MVC 5 pe .NET Framework, încă întâlnit în proiectele mai vechi.

Ce urmărește intervievatorul: Întrebare de deschidere. Se verifică imaginea de ansamblu și dacă știi ce face efectiv serverul web.

56 Junior

Ce este pipeline-ul de middleware în ASP.NET Core și de ce contează ordinea?

Răspuns scurt: Middleware-ul este o serie de componente prin care trece fiecare cerere, în ordinea înregistrării, iar răspunsul trece înapoi în ordine inversă. Fiecare poate procesa cererea, o poate opri sau o poate trimite mai departe, deci ordinea determină comportamentul.

Fiecare middleware primește HttpContext și o referință la următorul. Poate face ceva înainte, poate apela next() și poate face ceva după.

C#
var app = builder.Build();

app.UseExceptionHandler("/error");   // primul: prinde excepțiile tuturor celor de după
app.UseHttpsRedirection();
app.UseStaticFiles();                 // fișiere statice: răspunde și oprește lanțul
app.UseRouting();
app.UseCors("Frontend");
app.UseAuthentication();              // cine ești
app.UseAuthorization();               // ce ai voie
app.MapControllers();

// middleware propriu, inline
app.Use(async (context, next) =>
{
    var sw = Stopwatch.StartNew();
    await next(context);
    app.Logger.LogInformation("{Path} în {Ms} ms",
        context.Request.Path, sw.ElapsedMilliseconds);
});

De ce contează ordinea:

  • UseExceptionHandler trebuie pus devreme, altfel nu prinde erorile din componentele înregistrate înaintea lui;
  • UseAuthentication trebuie să fie înainte de UseAuthorization; invers, utilizatorul pare mereu anonim și primești 401;
  • UseCors trebuie să fie înainte de autorizare și după rutare;
  • UseStaticFiles înainte de autentificare face ca fișierele statice să fie publice și servite rapid.

Un middleware care nu apelează next scurtcircuitează pipeline-ul (de exemplu un răspuns din cache sau un 429 de la rate limiting). Atenție: după ce răspunsul a început să fie trimis, nu mai poți modifica status code-ul sau header-ele.

Pentru logică reutilizabilă, scrii o clasă cu metoda InvokeAsync(HttpContext) și o înregistrezi cu app.UseMiddleware<T>().

Ce urmărește intervievatorul: Verifică înțelegerea fluxului unei cereri. Greșelile de ordine între autentificare, autorizare și CORS sunt foarte frecvente în practică.

57 Junior

Care este diferența dintre controllere și minimal APIs?

Răspuns scurt: Controllerele grupează acțiuni în clase derivate din ControllerBase, cu atribute, filtre și convenții MVC. Minimal APIs (din .NET 6) definesc endpoint-uri direct cu MapGet sau MapPost și lambda-uri, cu mai puțin cod și overhead mai mic.

Controllerele sunt modelul clasic: o clasă per resursă, metode pentru fiecare acțiune, rutare prin atribute, model binding, validare automată cu [ApiController] și filtre pentru aspecte transversale.

C#
[ApiController]
[Route("api/produse")]
public class ProduseController : ControllerBase
{
    private readonly IProdusService _svc;
    public ProduseController(IProdusService svc) => _svc = svc;

    [HttpGet("{id:int}")]
    public async Task<ActionResult<ProdusDto>> Get(int id) =>
        await _svc.GetAsync(id) is { } p ? Ok(p) : NotFound();
}

Minimal APIs definesc același endpoint fără clasă, cu dependențele injectate direct ca parametri:

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

produse.MapGet("/{id:int}", async (int id, IProdusService svc) =>
    await svc.GetAsync(id) is { } p ? Results.Ok(p) : Results.NotFound());

Cum alegi:

  • minimal APIs: mai puțin cod, pornire și execuție ușor mai rapide, compatibile cu Native AOT; potrivite pentru microservicii și API-uri mici sau medii;
  • controllere: structură familiară pentru echipe mari, filtre MVC, suport matur pentru unele scenarii (de exemplu OData sau convenții personalizate);
  • funcționalitățile s-au apropiat între timp: minimal APIs au MapGroup (din .NET 7), filtre de endpoint, TypedResults, validare și integrare OpenAPI.

Indiferent de stil, logica de business trebuie să stea în servicii, nu în endpoint. Endpoint-ul primește cererea, apelează serviciul și traduce rezultatul în cod HTTP.

Ce urmărește intervievatorul: Verifică dacă ești la curent cu .NET modern și dacă alegi argumentat. Greșeala tipică: logică de business pusă direct în controller.

58 Junior

Ce este dependency injection și cum funcționează în ASP.NET Core?

Răspuns scurt: Dependency injection înseamnă că o clasă își primește dependențele din exterior, de obicei prin constructor, în loc să le creeze singură. ASP.NET Core are un container inclus: înregistrezi servicii în builder.Services, iar framework-ul le creează și le injectează automat.

Fără DI, o clasă își creează singură dependențele (new SmtpEmailSender()), deci este legată de o implementare concretă și greu de testat. Cu DI, clasa declară ce îi trebuie, iar containerul se ocupă de construcție.

C#
public interface IEmailSender { Task TrimiteAsync(string catre, string subiect); }
public class SmtpEmailSender : IEmailSender { /* ... */ }

public class ComandaService
{
    private readonly IEmailSender _email;
    private readonly ILogger<ComandaService> _logger;

    public ComandaService(IEmailSender email, ILogger<ComandaService> logger)
        => (_email, _logger) = (email, logger);
}

// Program.cs
builder.Services.AddScoped<IEmailSender, SmtpEmailSender>();
builder.Services.AddScoped<ComandaService>();

Când o cerere ajunge la un controller care are nevoie de ComandaService, containerul vede că acesta cere IEmailSender și ILogger<T>, le construiește (recursiv), apoi creează serviciul. Tot containerul apelează Dispose la finalul duratei de viață.

Beneficii:

  • testabilitate: în teste injectezi un fake de IEmailSender;
  • cuplare redusă: schimbi implementarea dintr-un singur loc;
  • gestionarea duratei de viață (singleton, scoped, transient) este centralizată.

Detalii utile: dacă înregistrezi mai multe implementări pentru aceeași interfață, constructorul care cere IEnumerable<IEmailSender> le primește pe toate, iar cel care cere una singură o primește pe ultima înregistrată. Din .NET 8 există și keyed services (AddKeyedScoped și [FromKeyedServices("cheie")]). Evită pattern-ul „service locator” (provider.GetService peste tot), care ascunde dependențele.

Ce urmărește intervievatorul: E una dintre cele mai sigure întrebări la un interviu .NET. Se verifică motivația (testare, cuplare), nu doar sintaxa de înregistrare.

59 Junior

Care este diferența dintre Singleton, Scoped și Transient?

Răspuns scurt: Singleton creează o singură instanță pentru toată viața aplicației. Scoped creează o instanță per scope, adică per cerere HTTP în ASP.NET Core. Transient creează o instanță nouă la fiecare rezolvare.

  • Transient (AddTransient): obiect nou de fiecare dată când e cerut, inclusiv de două ori în aceeași cerere. Potrivit pentru servicii ușoare, fără stare.
  • Scoped (AddScoped): o instanță per scope. În ASP.NET Core, framework-ul creează un scope pentru fiecare cerere HTTP, deci toate componentele dintr-o cerere primesc aceeași instanță. DbContext este înregistrat implicit scoped prin AddDbContext.
  • Singleton (AddSingleton): o singură instanță, partajată de toate cererile și de toate thread-urile. Potrivit pentru configurare, cache-uri în memorie, clienți costisitori de creat. Trebuie să fie thread-safe.
C#
builder.Services.AddSingleton<IRataSchimbCache, RataSchimbCache>();
builder.Services.AddScoped<IComandaRepository, ComandaRepository>();
builder.Services.AddTransient<IValidatorComanda, ValidatorComanda>();
builder.Services.AddDbContext<AppDbContext>(o =>
    o.UseSqlServer(builder.Configuration.GetConnectionString("Db")));

Cum alegi:

  • serviciul are stare legată de utilizator sau de cerere, ori depinde de DbContext? Scoped;
  • e scump de creat, fără stare per utilizator și thread-safe? Singleton;
  • e mic, fără stare? Transient sau scoped, ambele sunt în regulă.

În afara unei cereri (de exemplu într-un BackgroundService, care este singleton), nu există scope automat. Pentru a folosi servicii scoped acolo, creezi explicit un scope:

C#
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();

Cea mai importantă regulă: un serviciu nu are voie să depindă de unul cu durată de viață mai scurtă (de exemplu singleton care primește scoped), problemă numită captive dependency.

Ce urmărește intervievatorul: Este probabil cea mai frecventă întrebare ASP.NET Core. Se verifică înțelegerea unui scope per cerere și a regulii de dependență între durate de viață.

60 Junior

Cum funcționează rutarea și model binding-ul? Ce fac [FromBody], [FromQuery] și [FromRoute]?

Răspuns scurt: Rutarea potrivește URL-ul și metoda HTTP cu un endpoint. Model binding-ul completează parametrii acțiunii din cerere: rută, query string, body JSON, header-e sau formular. Atributele [From...] spun explicit sursa fiecărui parametru.

C#
[ApiController]
[Route("api/clienti")]
public class ClientiController : ControllerBase
{
    // GET api/clienti/42/comenzi?pagina=2&status=platita
    [HttpGet("{id:int}/comenzi")]
    public IActionResult Comenzi(
        [FromRoute] int id,
        [FromQuery] int pagina = 1,
        [FromQuery] string? status = null,
        [FromHeader(Name = "X-Correlation-Id")] string? corelare = null)
        => Ok(new { id, pagina, status, corelare });

    // POST api/clienti cu body JSON
    [HttpPost]
    public IActionResult Creeaza([FromBody] ClientNouDto dto) =>
        CreatedAtAction(nameof(Comenzi), new { id = 1 }, dto);
}

public record ClientNouDto(string Nume, string Email);

Cum funcționează:

  • {id:int} este un parametru de rută cu constrângere: /api/clienti/abc nu se potrivește și dă 404, în loc să ajungă în acțiune;
  • cu [ApiController], sursele se deduc: tipurile complexe vin din body, tipurile simple din rută dacă numele apare în șablon, altfel din query; atributele explicite fac codul mai clar;
  • body-ul poate fi citit o singură dată, deci doar un parametru poate avea [FromBody];
  • deserializarea JSON se face cu System.Text.Json, implicit cu nume de proprietăți în camelCase și potrivire case-insensitive.

În minimal APIs regulile sunt asemănătoare: parametrii simpli vin din rută sau query, tipurile complexe din body, serviciile înregistrate din DI, iar [AsParameters] grupează mai mulți parametri într-o clasă.

Dacă binding-ul eșuează (JSON invalid, tip greșit), [ApiController] întoarce automat 400 Bad Request cu detaliile problemei.

Ce urmărește intervievatorul: Verifică dacă știi de unde vin datele în acțiuni. Greșeala tipică: două obiecte [FromBody] în aceeași acțiune.

61 Junior

Ce coduri de status HTTP ar trebui să întoarcă un API REST și cum le întorci în ASP.NET Core?

Răspuns scurt: Codurile 2xx înseamnă succes (200 OK, 201 Created, 204 No Content), 4xx erori ale clientului (400, 401, 403, 404, 409, 422) și 5xx erori ale serverului (500, 503). În ASP.NET Core le întorci cu Ok(), CreatedAtAction(), NotFound() sau cu Results în minimal APIs.

Un API bine proiectat folosește codurile corect, ca clienții să poată reacționa automat:

  • 200 OK: citire sau actualizare reușită, cu conținut;
  • 201 Created: resursă creată, cu header-ul Location către ea;
  • 204 No Content: succes fără corp, de exemplu la DELETE;
  • 400 Bad Request: date invalide sau JSON greșit;
  • 401 Unauthorized: lipsește autentificarea sau token-ul e invalid;
  • 403 Forbidden: utilizatorul e autentificat, dar nu are drept;
  • 404 Not Found: resursa nu există;
  • 409 Conflict: conflict de stare, de exemplu email deja folosit sau versiune expirată;
  • 500 Internal Server Error: excepție neprevăzută; detaliile nu se expun clientului.
C#
[HttpPost]
public async Task<ActionResult<ProdusDto>> Creeaza(ProdusNouDto dto)
{
    if (await _svc.ExistaAsync(dto.Cod))
        return Conflict(new { mesaj = "Codul există deja" });

    var p = await _svc.CreeazaAsync(dto);
    return CreatedAtAction(nameof(Get), new { id = p.Id }, p);
}

[HttpDelete("{id:int}")]
public async Task<IActionResult> Sterge(int id) =>
    await _svc.StergeAsync(id) ? NoContent() : NotFound();

ActionResult<T> permite întoarcerea fie a unui T (serializat cu 200), fie a unui alt rezultat, și ajută generatorul OpenAPI să documenteze tipul. În minimal APIs, TypedResults.Ok(p) și tipul Results<Ok<ProdusDto>, NotFound> fac același lucru tipizat.

Greșeli frecvente: 200 cu { "success": false } în corp, 500 pentru validări, 401 în loc de 403.

Ce urmărește intervievatorul: Se verifică dacă proiectezi API-uri pe care alți dezvoltatori le pot consuma ușor. Confuzia 401 vs 403 apare foarte des.

62 Mid

Cum funcționează configurarea în ASP.NET Core și ce este Options pattern?

Răspuns scurt: Configurarea combină mai multe surse în ordine (appsettings.json, appsettings.{Environment}.json, user secrets, variabile de mediu, argumente), iar sursele ulterioare le suprascriu pe cele anterioare. Options pattern leagă o secțiune de configurare de o clasă tipizată, injectată prin IOptions<T>.

WebApplication.CreateBuilder încarcă implicit, în această ordine: appsettings.json, appsettings.{Environment}.json (de exemplu Development), user secrets (doar în Development), variabile de mediu, argumente din linia de comandă. Ultima sursă care definește o cheie câștigă.

JSON
{
  "Email": {
    "Server": "smtp.exemplu.ro",
    "Port": 587,
    "Expeditor": "noreply@exemplu.ro"
  }
}
C#
public class EmailOptions
{
    public const string Sectiune = "Email";
    [Required] public string Server { get; set; } = "";
    [Range(1, 65535)] public int Port { get; set; }
    public string Expeditor { get; set; } = "";
}

builder.Services.AddOptions<EmailOptions>()
    .Bind(builder.Configuration.GetSection(EmailOptions.Sectiune))
    .ValidateDataAnnotations()
    .ValidateOnStart();

public class EmailSender(IOptions<EmailOptions> opt)
{
    private readonly EmailOptions _cfg = opt.Value;
}

Variante de injectare:

  • IOptions<T>: valoare citită o dată, singleton;
  • IOptionsSnapshot<T>: recitită per cerere (scoped), vede modificările din fișier;
  • IOptionsMonitor<T>: singleton cu notificare la schimbări, util în servicii singleton.

În variabile de mediu, ierarhia se scrie cu două caractere underscore: Email__Port=2525, convenție folosită des în Docker și Kubernetes.

Secretele (parole, chei API, connection string-uri de producție) nu se pun în appsettings.json din repository. În dezvoltare folosești dotnet user-secrets, iar în producție variabile de mediu sau un seif ca Azure Key Vault. ValidateOnStart face ca aplicația să nu pornească deloc cu o configurare greșită, în loc să eșueze la prima cerere.

Ce urmărește intervievatorul: Verifică dacă știi ordinea surselor și unde stau secretele. Mulți candidați citesc configurarea cu string-uri magice peste tot.

63 Mid

Ce este o captive dependency și cum o detectezi?

Răspuns scurt: Captive dependency apare când un serviciu cu viață lungă, de obicei singleton, primește în constructor unul cu viață mai scurtă, scoped sau transient, și îl ține captiv mult peste durata lui. Rezultatul: DbContext partajat între cereri, date amestecate între utilizatori, erori de concurență.

C#
builder.Services.AddDbContext<AppDbContext>();            // scoped
builder.Services.AddSingleton<RaportCache>();             // singleton

public class RaportCache
{
    private readonly AppDbContext _db; // captiv: creat o dată, folosit de toate cererile
    public RaportCache(AppDbContext db) => _db = db;
}

Aici, AppDbContext ar trebui să trăiască o cerere. Ținut de un singleton, același context este folosit de toate cererile, pe mai multe thread-uri. DbContext nu este thread-safe, deci apar excepții de tipul „A second operation was started on this context”, iar change tracker-ul acumulează entități la nesfârșit.

Detectare: în mediul Development, ASP.NET Core activează implicit validarea scope-urilor (ValidateScopes), deci aplicația aruncă la rezolvarea serviciului: „Cannot consume scoped service from singleton”. Poți activa explicit verificarea și în alte medii:

C#
builder.Host.UseDefaultServiceProvider(o =>
{
    o.ValidateScopes = true;
    o.ValidateOnBuild = true; // verifică tot graful la pornire
});

Atenție: un transient injectat într-un singleton nu este semnalat, dar devine de facto singleton; dacă acel transient ține stare sau resurse, problema e aceeași.

Soluții:

  • schimbă durata de viață a consumatorului (de exemplu scoped);
  • injectează IServiceScopeFactory și creează un scope la fiecare utilizare;
  • pentru EF Core, folosește IDbContextFactory<AppDbContext> (AddDbContextFactory) și creează un context scurt per operație.

Ce urmărește intervievatorul: Este o problemă reală, întâlnită des în producție. Intervievatorul caută explicația consecințelor și mecanismul de detectare.

64 Mid

Cum implementezi validarea și tratarea globală a erorilor într-un API ASP.NET Core?

Răspuns scurt: Validarea cererilor se face cu Data Annotations sau FluentValidation, iar [ApiController] întoarce automat 400 cu ProblemDetails. Pentru erori neprevăzute, un handler global (UseExceptionHandler cu IExceptionHandler din .NET 8) transformă excepțiile în răspunsuri ProblemDetails consecvente, fără să expună detalii interne.

Validarea datelor de intrare:

C#
public record ClientNouDto(
    [Required, StringLength(100)] string Nume,
    [Required, EmailAddress] string Email,
    [Range(18, 120)] int Varsta);

Cu [ApiController], dacă modelul e invalid, acțiunea nici nu rulează: clientul primește 400 cu un obiect ValidationProblemDetails (standardul RFC 7807/9457), care listează erorile pe câmpuri. Pentru reguli complexe sau dependente de alte câmpuri, multe echipe folosesc biblioteca FluentValidation.

Erori globale, cu IExceptionHandler (din .NET 8):

C#
public class GlobalExceptionHandler(ILogger<GlobalExceptionHandler> log) : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(
        HttpContext ctx, Exception ex, CancellationToken ct)
    {
        var (status, titlu) = ex switch
        {
            NotFoundException => (404, "Resursa nu există"),
            ConflictException => (409, "Conflict"),
            _ => (500, "Eroare internă")
        };
        if (status == 500) log.LogError(ex, "Eroare neprevăzută");

        ctx.Response.StatusCode = status;
        await ctx.Response.WriteAsJsonAsync(
            new ProblemDetails { Status = status, Title = titlu }, ct);
        return true;
    }
}

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

Principii:

  • un singur loc pentru maparea excepțiilor la coduri HTTP, nu try/catch în fiecare acțiune;
  • detaliile tehnice (stack trace, mesaje SQL) se loghează, dar nu ajung la client în producție;
  • includerea unui traceId în răspuns ajută la corelarea plângerii unui utilizator cu logurile.

Ce urmărește intervievatorul: Verifică dacă scrii API-uri robuste și consecvente. Răspunsul slab: try/catch în fiecare controller cu return 500.

65 Mid

Care este diferența dintre autentificare și autorizare? Cum protejezi un API cu JWT?

Răspuns scurt: Autentificarea stabilește cine este utilizatorul, autorizarea stabilește ce are voie să facă. Pentru JWT, configurezi AddAuthentication().AddJwtBearer cu emitentul, audiența și cheia de semnare, apoi protejezi endpoint-urile cu [Authorize], roluri sau politici.

Un JWT (JSON Web Token) este un token semnat care conține claims: id-ul utilizatorului, roluri, data expirării. Clientul îl trimite în header-ul Authorization: Bearer <token>, iar API-ul verifică semnătura fără să interogheze o bază de date de sesiuni.

C#
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(o =>
    {
        o.Authority = "https://login.exemplu.ro";   // furnizorul de identitate
        o.Audience = "api-comenzi";
    });

builder.Services.AddAuthorization(o =>
    o.AddPolicy("PoateRambursa", p => p.RequireClaim("permisiune", "rambursare")));

app.UseAuthentication();
app.UseAuthorization();

[Authorize]
[ApiController, Route("api/comenzi")]
public class ComenziController : ControllerBase
{
    [HttpGet] public IActionResult Lista() => Ok(User.Identity!.Name);

    [Authorize(Roles = "Admin")]
    [HttpDelete("{id}")] public IActionResult Sterge(int id) => NoContent();

    [Authorize(Policy = "PoateRambursa")]
    [HttpPost("{id}/rambursare")] public IActionResult Ramburseaza(int id) => Ok();
}

Cu Authority, middleware-ul descarcă automat cheile publice ale emitentului (OpenID Connect discovery) și validează semnătura, emitentul, audiența și expirarea.

Aspecte importante:

  • JWT-ul este semnat, nu criptat: oricine îl poate decoda, deci nu pune date sensibile în el;
  • tokenurile de acces au viață scurtă, iar reîmprospătarea se face cu refresh tokens;
  • un JWT nu poate fi revocat ușor înainte de expirare, de aceea durata scurtă contează;
  • pentru reguli care depind de resursă („doar autorul comenzii o poate modifica”) folosești IAuthorizationService cu un handler de resursă.

În practică, emiterea token-urilor e lăsată unui furnizor dedicat (Entra ID, Keycloak, Auth0, Duende IdentityServer), nu scrisă de mână.

Ce urmărește intervievatorul: Se verifică diferența conceptuală și dacă știi ce validează middleware-ul. Mulți candidați cred că JWT-ul e criptat.

66 Mid

Cum faci logging corect într-o aplicație ASP.NET Core? Ce înseamnă structured logging?

Răspuns scurt: Folosești ILogger<T> injectat, cu niveluri potrivite și template-uri cu parametri numiți în loc de interpolare. Structured logging păstrează parametrii ca proprietăți separate, ca să poți căuta și filtra logurile după ei într-un sistem ca Seq, Elasticsearch sau Application Insights.

C#
public class PlataService(ILogger<PlataService> logger)
{
    public async Task ProceseazaAsync(int comandaId, decimal suma)
    {
        logger.LogInformation("Procesez plata pentru comanda {ComandaId}, suma {Suma}",
            comandaId, suma);
        try
        {
            await Task.Delay(10);
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Plata a eșuat pentru comanda {ComandaId}", comandaId);
            throw;
        }
    }
}

Structured logging: template-ul {ComandaId} nu este doar formatare. Provider-ul primește separat mesajul-șablon și valorile, deci în sistemul de loguri poți căuta „toate erorile pentru ComandaId = 1234” sau poți grupa după șablon. Cu interpolare ($"...{comandaId}"), totul devine un string unic și pierzi structura; în plus, string-ul este construit chiar dacă nivelul e dezactivat.

Niveluri (Trace, Debug, Information, Warning, Error, Critical), configurate per categorie în appsettings.json:

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

Bune practici:

  • excepția se transmite ca prim parametru, nu în mesaj, ca stack trace-ul să fie păstrat;
  • nu loga date personale, parole sau token-uri;
  • folosește BeginScope sau corelarea automată (TraceId din OpenTelemetry) ca să legi logurile aceleiași cereri;
  • pentru cod executat foarte des, atributul [LoggerMessage] generează la compilare metode de logging fără alocări.

Biblioteci populare: Serilog și NLog, plus OpenTelemetry pentru loguri, metrici și trace-uri distribuite.

Ce urmărește intervievatorul: Verifică maturitatea operațională. Diferența dintre template și interpolare este exact detaliul pe care îl caută intervievatorul.

67 Senior

Ce strategii de caching folosești într-un API ASP.NET Core și ce probleme pot apărea?

Răspuns scurt: Ai caching în memorie (IMemoryCache), distribuit (IDistributedCache cu Redis), HybridCache (din .NET 9) și output caching pentru răspunsuri HTTP întregi. Problemele tipice sunt invalidarea, datele învechite, cache stampede și consumul necontrolat de memorie.

Opțiuni, de la simplu la complex:

  • IMemoryCache: în procesul aplicației, foarte rapid, dar fiecare instanță are propria copie și se pierde la restart;
  • IDistributedCache (Redis, SQL Server): partajat între instanțe, supraviețuiește restartului aplicației, dar implică serializare și apel de rețea;
  • HybridCache (.NET 9): combină un nivel local cu unul distribuit și protejează împotriva cache stampede;
  • Output caching (.NET 7+): cache-uiește răspunsuri HTTP întregi pe server, cu politici și invalidare pe tag-uri;
  • Response caching și header-ele HTTP (Cache-Control, ETag): cache la client, proxy sau CDN.
C#
builder.Services.AddMemoryCache();

public class CursValutarService(IMemoryCache cache, ICursClient client)
{
    public Task<decimal?> GetAsync(string moneda) =>
        cache.GetOrCreateAsync($"curs:{moneda}", async intrare =>
        {
            intrare.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10);
            return await client.GetCursAsync(moneda);
        });
}

Probleme de discutat:

  • invalidarea: când se schimbă datele sursă, cine șterge intrarea? Expirarea pe timp e simplă, dar acceptă date vechi; invalidarea explicită e corectă, dar ușor de uitat într-un loc;
  • cache stampede: când o cheie populară expiră, sute de cereri o recalculează simultan; GetOrCreateAsync din IMemoryCache nu previne asta, HybridCache sau un lock per cheie da;
  • memorie: fără SizeLimit și expirare, cache-ul crește la nesfârșit;
  • date per utilizator: o cheie care nu include utilizatorul poate servi datele cuiva altcuiva, o problemă de securitate.

Regula: măsori întâi unde e lentoarea, cache-uiești date citite des și modificate rar, și decizi explicit cât de vechi pot fi datele.

Ce urmărește intervievatorul: Întrebare de senior despre compromisuri. Se urmărește discutarea invalidării și a riscurilor, nu doar sintaxa IMemoryCache.

68 Senior

Un endpoint care mergea bine a devenit lent în producție. Cum ai investiga?

Răspuns scurt: Pornești de la date, nu de la presupuneri: confirmi și cuantifici problema în metrici, izolezi componenta lentă cu tracing distribuit și loguri, verifici interogările SQL și dependențele externe, apoi reproduci și măsori înainte și după remediere.

Un răspuns structurat pe pași:

  • Confirmă și delimitează: din metrici (Application Insights, Prometheus și Grafana, Datadog), vezi de când e lent, dacă e doar endpoint-ul acesta, dacă afectează percentilele mari (p95, p99) sau toate cererile, dacă se corelează cu un deploy sau cu creșterea traficului.
  • Urmărește o cerere lentă: tracing-ul distribuit (OpenTelemetry) arată cât durează fiecare pas: interogări SQL, apeluri HTTP externe, cache. De obicei, timpul e dominat de o singură componentă.
  • Baza de date: cele mai frecvente cauze sunt interogări noi sau modificate, N+1 introdus de un Include lipsă, un index lipsă după creșterea volumului de date, planuri de execuție schimbate. Activezi logarea SQL din EF Core, verifici planul de execuție și statisticile de așteptare.
  • Aplicația: dotnet-counters pentru thread pool (lungimea cozii crește? semn de thread pool starvation din cauza unui .Result sau .Wait()), colectări GC frecvente, excepții multe aruncate. dotnet-trace sau un profiler pentru cod CPU-bound.
  • Dependențe externe: un API terț mai lent, timeout-uri și retry-uri care se adună, epuizarea conexiunilor.
BASH
dotnet-counters monitor -p 1234 --counters System.Runtime,Microsoft.AspNetCore.Hosting
dotnet-trace collect -p 1234 --duration 00:00:30

După ce găsești cauza: reproduci local sau în staging cu date de volum similar, aplici remedierea, măsori din nou și adaugi o alertă sau un test de performanță ca regresia să nu treacă neobservată. La interviu, arată că nu schimbi lucruri la întâmplare și că știi să te oprești când ai dovezi.

Ce urmărește intervievatorul: Testează metoda de lucru sub presiune și cunoașterea uneltelor de observabilitate. Răspunsul slab sare direct la „adaug cache”.

Entity Framework Core și SQL

69 Junior

Ce este Entity Framework Core și ce rol are DbContext?

Răspuns scurt: EF Core este ORM-ul oficial din .NET: mapează clase C# pe tabele și traduce interogări LINQ în SQL. DbContext reprezintă o sesiune de lucru cu baza de date: expune DbSet-uri, urmărește modificările entităților și le salvează cu SaveChanges.

Un ORM (Object-Relational Mapper) elimină codul repetitiv de citire din DataReader și de construire a comenzilor SQL. Scrii clase și interogări LINQ, iar EF Core generează SQL-ul pentru provider-ul ales (SQL Server, PostgreSQL, SQLite, MySQL și altele).

C#
public class Produs
{
    public int Id { get; set; }
    public string Nume { get; set; } = "";
    public decimal Pret { get; set; }
    public int CategorieId { get; set; }
    public Categorie Categorie { get; set; } = null!;
}

public class AppDbContext(DbContextOptions<AppDbContext> options) : DbContext(options)
{
    public DbSet<Produs> Produse => Set<Produs>();
    public DbSet<Categorie> Categorii => Set<Categorie>();

    protected override void OnModelCreating(ModelBuilder mb)
    {
        mb.Entity<Produs>().Property(p => p.Pret).HasPrecision(10, 2);
        mb.Entity<Produs>().HasIndex(p => p.Nume);
    }
}

// utilizare
var ieftine = await db.Produse.Where(p => p.Pret < 100).ToListAsync();
db.Produse.Add(new Produs { Nume = "Mouse", Pret = 90, CategorieId = 1 });
await db.SaveChangesAsync();

Responsabilitățile DbContext:

  • change tracking: ține evidența entităților încărcate și a stării lor (Added, Modified, Deleted, Unchanged);
  • unit of work: SaveChanges trimite toate modificările într-o tranzacție;
  • identity map: aceeași entitate încărcată de două ori în același context este aceeași instanță.

DbContext este gândit să fie de viață scurtă (o cerere HTTP, o unitate de lucru) și nu este thread-safe. Configurarea se face prin convenții (Id devine cheie primară), atribute sau Fluent API în OnModelCreating, care e cea mai expresivă variantă.

Ce urmărește intervievatorul: Întrebare de bază. Se verifică dacă înțelegi că DbContext e o unitate de lucru cu viață scurtă, nu o conexiune globală.

70 Junior

Ce sunt migrările în EF Core și cum le folosești în echipă?

Răspuns scurt: Migrările sunt fișiere C# generate din diferența dintre modelul curent și ultima versiune cunoscută a schemei. Le creezi cu dotnet ef migrations add, le aplici cu dotnet ef database update sau cu scripturi SQL generate, și le versionezi în Git împreună cu codul.

Fluxul obișnuit:

BASH
dotnet tool install --global dotnet-ef
dotnet ef migrations add AdaugaStocProdus
dotnet ef database update
dotnet ef migrations script --idempotent -o migrare.sql

migrations add compară modelul cu snapshot-ul (AppDbContextModelSnapshot.cs) și generează o clasă cu metodele Up (aplică schimbarea) și Down (o anulează):

C#
public partial class AdaugaStocProdus : Migration
{
    protected override void Up(MigrationBuilder mb) =>
        mb.AddColumn<int>("Stoc", "Produse", nullable: false, defaultValue: 0);

    protected override void Down(MigrationBuilder mb) =>
        mb.DropColumn("Stoc", "Produse");
}

Baza de date ține tabelul __EFMigrationsHistory cu migrările deja aplicate.

Practici în echipă:

  • verifică migrarea generată înainte de commit: o redenumire de proprietate poate fi interpretată ca ștergere de coloană și adăugare de coloană nouă, cu pierdere de date; o corectezi cu RenameColumn;
  • conflicte: doi colegi care adaugă migrări în paralel creează snapshot-uri divergente; după merge, se regenerează ultima migrare sau se rezolvă conflictul în snapshot;
  • nu modifica migrări deja aplicate în alte medii; adaugi una nouă;
  • producție: în loc de Database.Migrate() la pornirea aplicației (riscant cu mai multe instanțe care pornesc simultan), se preferă scripturi idempotente rulate în pipeline-ul de CI/CD sau bundle-uri (dotnet ef migrations bundle);
  • schimbările distructive (ștergere de coloane) se fac în mai mulți pași, ca versiunea veche a aplicației să funcționeze în timpul deploy-ului.

Ce urmărește intervievatorul: Verifică experiența de lucru real cu schema bazei de date. Pericolul redenumirii interpretate ca ștergere e un detaliu apreciat.

71 Junior

Explică tipurile de JOIN din SQL cu un exemplu.

Răspuns scurt: INNER JOIN întoarce doar rândurile care au corespondent în ambele tabele. LEFT JOIN întoarce toate rândurile din tabela din stânga, cu NULL unde nu există corespondent. RIGHT JOIN e simetricul, iar FULL OUTER JOIN le întoarce pe toate din ambele părți.

Fie tabelele Clienti(Id, Nume) și Comenzi(Id, ClientId, Total).

SQL
-- doar clienții care au cel puțin o comandă
SELECT c.Nume, o.Total
FROM Clienti c
INNER JOIN Comenzi o ON o.ClientId = c.Id;

-- toți clienții, inclusiv cei fără comenzi (Total = NULL)
SELECT c.Nume, o.Total
FROM Clienti c
LEFT JOIN Comenzi o ON o.ClientId = c.Id;

-- clienții care NU au nicio comandă
SELECT c.Nume
FROM Clienti c
LEFT JOIN Comenzi o ON o.ClientId = c.Id
WHERE o.Id IS NULL;

Tipurile principale:

  • INNER JOIN: intersecția pe condiția de legătură;
  • LEFT (OUTER) JOIN: tot din stânga, plus potrivirile din dreapta;
  • RIGHT (OUTER) JOIN: tot din dreapta; se folosește rar, de obicei se rescrie ca LEFT JOIN inversând tabelele;
  • FULL OUTER JOIN: tot din ambele, cu NULL acolo unde lipsește corespondentul;
  • CROSS JOIN: produsul cartezian, fiecare rând cu fiecare rând.

Capcane:

  • un client cu trei comenzi apare de trei ori: JOIN-ul poate multiplica rândurile, deci un SUM pe coloanele clientului dă rezultate greșite;
  • condiția pusă în WHERE pe tabela din dreapta a unui LEFT JOIN (de exemplu WHERE o.Total > 100) îl transformă practic în INNER JOIN; dacă vrei să păstrezi clienții fără comenzi, condiția merge în ON.

În EF Core, navigările (Include, proiecții prin c.Comenzi) generează aceste JOIN-uri automat, dar e important să înțelegi SQL-ul produs.

Ce urmărește intervievatorul: Este o întrebare SQL nelipsită. Se verifică și capcana cu filtrul din WHERE care anulează LEFT JOIN-ul.

72 Junior

Scrie o interogare SQL care întoarce clienții cu peste 5 comenzi în 2026 și totalul lor, ordonați descrescător după total. Care e diferența dintre WHERE și HAVING?

Răspuns scurt: Filtrezi comenzile din 2026 cu WHERE, grupezi după client cu GROUP BY, păstrezi grupurile cu mai mult de 5 comenzi cu HAVING și ordonezi după suma totală. WHERE filtrează rânduri înainte de grupare, HAVING filtrează grupuri după agregare.

SQL
SELECT c.Id, c.Nume,
       COUNT(*)     AS NrComenzi,
       SUM(o.Total) AS TotalComenzi
FROM Clienti c
JOIN Comenzi o ON o.ClientId = c.Id
WHERE o.DataComanda >= '2026-01-01'
  AND o.DataComanda <  '2027-01-01'
GROUP BY c.Id, c.Nume
HAVING COUNT(*) > 5
ORDER BY TotalComenzi DESC;

Ordinea logică de evaluare a unei interogări explică diferența: FROM și JOIN, apoi WHERE, GROUP BY, HAVING, SELECT, ORDER BY. De aceea:

  • WHERE nu poate folosi funcții de agregare (COUNT, SUM), pentru că grupurile încă nu există;
  • HAVING lucrează pe grupuri și pe agregatele lor;
  • aliasul TotalComenzi poate fi folosit în ORDER BY (evaluat după SELECT), dar nu în WHERE.

Detalii pe care merită să le menționezi:

  • filtrul pe dată ca interval semideschis (>= și <) prinde corect toate orele din 31 decembrie și permite folosirea unui index pe DataComanda; varianta YEAR(o.DataComanda) = 2026 aplică o funcție pe coloană și împiedică de obicei folosirea indexului;
  • toate coloanele din SELECT care nu sunt agregate trebuie să apară în GROUP BY;
  • filtrele care pot fi puse în WHERE trebuie puse acolo, nu în HAVING, ca să reduci volumul înainte de grupare.

Echivalentul în EF Core:

C#
var top = await db.Comenzi
    .Where(o => o.DataComanda >= new DateTime(2026, 1, 1) && o.DataComanda < new DateTime(2027, 1, 1))
    .GroupBy(o => new { o.ClientId, o.Client.Nume })
    .Where(g => g.Count() > 5)
    .Select(g => new { g.Key.Nume, Nr = g.Count(), Total = g.Sum(o => o.Total) })
    .OrderByDescending(x => x.Total)
    .ToListAsync();

Ce urmărește intervievatorul: E un exercițiu tipic de live coding SQL. Se urmărește ordinea logică a clauzelor și filtrarea pe dată care poate folosi un index.

73 Junior

Ce este un index într-o bază de date și când îl adaugi?

Răspuns scurt: Un index este o structură separată, de obicei un B-tree, care permite găsirea rapidă a rândurilor după anumite coloane, fără scanarea întregului tabel. Îl adaugi pe coloanele folosite des în WHERE, JOIN și ORDER BY, știind că încetinește scrierile și ocupă spațiu.

Fără index, o interogare WHERE Email = 'ana@x.ro' pe un tabel cu milioane de rânduri citește tot tabelul (table scan). Cu un index pe Email, motorul caută în arbore în câțiva pași logaritmici.

SQL
CREATE UNIQUE INDEX IX_Clienti_Email ON Clienti(Email);

-- index compus: util pentru WHERE ClientId = ? ORDER BY DataComanda
CREATE INDEX IX_Comenzi_Client_Data ON Comenzi(ClientId, DataComanda);

În EF Core:

C#
mb.Entity<Client>().HasIndex(c => c.Email).IsUnique();
mb.Entity<Comanda>().HasIndex(o => new { o.ClientId, o.DataComanda });

Noțiuni importante:

  • clustered index (SQL Server): definește ordinea fizică a rândurilor; de obicei este cheia primară și poate exista unul singur per tabel;
  • non-clustered index: structură separată care indică rândurile; pot fi mai multe;
  • ordinea coloanelor într-un index compus contează: indexul (ClientId, DataComanda) ajută la căutare după ClientId sau după ambele, dar nu doar după DataComanda;
  • covering index: dacă indexul conține toate coloanele cerute (cu INCLUDE), motorul nu mai citește tabelul deloc.

Costuri: fiecare INSERT, UPDATE sau DELETE actualizează și indexurile, iar acestea ocupă spațiu. Un tabel cu zeci de indexuri inutile scrie lent. Indexurile pe coloane cu foarte puține valori distincte (de exemplu un bool) ajută rar.

Cum decizi: te uiți la planul de execuție al interogărilor lente (căutând scanări mari) și la statisticile motorului despre indexuri lipsă sau nefolosite, nu adaugi indexuri preventiv peste tot. Cheile străine din EF Core primesc automat indexuri prin convenție.

Ce urmărește intervievatorul: Verifică înțelegerea compromisului citire/scriere. Ordinea coloanelor în indexul compus este detaliul care separă răspunsurile bune.

74 Mid

Ce este problema N+1 în EF Core și cum o rezolvi?

Răspuns scurt: N+1 apare când încarci o listă de N entități cu o interogare, apoi pentru fiecare se execută încă o interogare ca să-i aduci relațiile. Se rezolvă încărcând relațiile din start cu Include sau, mai bine, proiectând direct în DTO-uri cu Select.

C#
// N+1 cu lazy loading activat: 1 interogare pentru comenzi + 1 pentru fiecare client
var comenzi = await db.Comenzi.ToListAsync();
foreach (var c in comenzi)
    Console.WriteLine(c.Client.Nume); // fiecare acces declanșează un SELECT

Pentru 500 de comenzi rezultă 501 interogări. Local, cu o bază mică, nu se observă; în producție, latența de rețea înmulțită de 500 de ori face pagina foarte lentă. Fără lazy loading, același cod nu face N+1, dar c.Client este null și primești NullReferenceException.

Soluții:

C#
// eager loading: un singur SELECT cu JOIN
var comenzi = await db.Comenzi
    .Include(c => c.Client)
    .Include(c => c.Linii).ThenInclude(l => l.Produs)
    .ToListAsync();

// proiecție: aduce doar coloanele necesare, fără tracking
var dto = await db.Comenzi
    .Select(c => new ComandaDto(c.Id, c.Client.Nume, c.Linii.Count))
    .ToListAsync();

Proiecția este adesea cea mai bună variantă: SQL-ul conține doar coloanele cerute, nu se urmăresc entități și nu ai nevoie de Include.

Atenție la explozia carteziană: mai multe Include pe colecții (linii, plăți, comentarii) într-un singur JOIN multiplică rândurile. EF Core 5+ oferă AsSplitQuery(), care execută câte o interogare per colecție, compromis între numărul de interogări și volumul de date.

Detectare: activează logarea comenzilor SQL (LogTo(Console.WriteLine) sau categoria Microsoft.EntityFrameworkCore.Database.Command) și urmărește câte interogări generează o pagină. Lazy loading-ul (pachetul Proxies) e dezactivat implicit în EF Core tocmai pentru că ascunde această problemă.

Ce urmărește intervievatorul: Este probabil cea mai frecventă problemă de performanță cu ORM-uri. Se apreciază menționarea proiecțiilor și a AsSplitQuery.

75 Mid

Ce face change tracking-ul în EF Core și când folosești AsNoTracking?

Răspuns scurt: Change tracker-ul memorează entitățile încărcate și valorile lor originale, ca SaveChanges să genereze automat UPDATE-urile necesare. Pentru interogări doar de citire, AsNoTracking evită acest cost, reducând memoria și timpul de procesare.

Când încarci o entitate obișnuit, EF Core o înregistrează în ChangeTracker cu starea Unchanged și păstrează o copie a valorilor originale. La SaveChanges, compară valorile curente cu cele originale și generează UPDATE doar pentru coloanele modificate.

C#
var produs = await db.Produse.FirstAsync(p => p.Id == 5);
produs.Pret = 99m;                // nu e nevoie de db.Update(produs)
await db.SaveChangesAsync();      // UPDATE Produse SET Pret = @p0 WHERE Id = @p1

Console.WriteLine(db.Entry(produs).State); // Unchanged, după salvare

Pentru citire pură (liste afișate, rapoarte, endpoint-uri GET), tracking-ul este cost inutil:

C#
var lista = await db.Produse
    .AsNoTracking()
    .Where(p => p.Activ)
    .ToListAsync();

Diferențe și nuanțe:

  • AsNoTracking este mai rapid și consumă mai puțină memorie, mai ales la volume mari;
  • fără tracking nu ai identity resolution: același client care apare în 100 de comenzi devine 100 de obiecte separate; AsNoTrackingWithIdentityResolution rezolvă asta;
  • proiecțiile în DTO-uri (Select(p => new ProdusDto(...))) nu sunt urmărite oricum;
  • poți schimba comportamentul implicit al contextului cu UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking) și să activezi tracking-ul explicit doar unde modifici.

O capcană legată de tracking: un context de viață lungă acumulează mii de entități urmărite, iar fiecare SaveChanges sau DetectChanges devine tot mai lent. De aceea contextul trebuie să fie scurt. Pentru actualizări în masă, EF Core 7+ are ExecuteUpdateAsync și ExecuteDeleteAsync, care trimit direct un UPDATE sau DELETE fără să încarce entitățile.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce se întâmplă în spatele SaveChanges. Bonus pentru ExecuteUpdate și pentru capcana contextului de viață lungă.

76 Mid

Ce înseamnă ACID și cum lucrezi cu tranzacții în EF Core? Ce sunt nivelurile de izolare?

Răspuns scurt: ACID înseamnă atomicitate, consistență, izolare și durabilitate. SaveChanges rulează implicit într-o tranzacție; pentru mai multe operații legate folosești Database.BeginTransactionAsync. Nivelurile de izolare stabilesc ce vede o tranzacție din modificările altora.

  • Atomicitate: toate operațiile reușesc sau niciuna; la eroare se face rollback.
  • Consistență: tranzacția duce baza dintr-o stare validă în alta validă (constrângeri, chei străine).
  • Izolare: tranzacțiile concurente nu se influențează în moduri nepermise.
  • Durabilitate: odată confirmată (commit), modificarea supraviețuiește unei căderi.

În EF Core, un singur SaveChanges este deja atomic. Ai nevoie de tranzacție explicită când combini mai multe SaveChanges, comenzi SQL directe sau ExecuteUpdateAsync:

C#
await using var tx = await db.Database.BeginTransactionAsync();
try
{
    var cont = await db.Conturi.SingleAsync(c => c.Id == sursaId);
    cont.Sold -= suma;
    await db.SaveChangesAsync();

    db.Transferuri.Add(new Transfer { SursaId = sursaId, Suma = suma });
    await db.SaveChangesAsync();

    await tx.CommitAsync();
}
catch
{
    await tx.RollbackAsync();
    throw;
}

Niveluri de izolare (SQL standard), de la slab la strict:

  • Read Uncommitted: poți citi date necomise (dirty reads);
  • Read Committed: implicit în SQL Server și PostgreSQL; vezi doar date comise, dar o recitire poate da altă valoare;
  • Repeatable Read: rândurile citite nu se schimbă până la final, dar pot apărea rânduri noi (phantom reads);
  • Serializable: tranzacțiile se comportă ca și cum ar rula una după alta; cel mai sigur, cu cele mai multe blocări.

SQL Server oferă și Snapshot (și READ_COMMITTED_SNAPSHOT), bazat pe versiuni de rânduri, care reduce blocările dintre cititori și scriitori. Tranzacțiile trebuie ținute scurte: nu apela API-uri externe și nu aștepta input de la utilizator în interiorul unei tranzacții deschise.

Ce urmărește intervievatorul: Verifică înțelegerea consistenței datelor. Mulți candidați nu știu că SaveChanges e deja tranzacțional.

77 Mid

Ce este SQL injection și cum te protejezi când scrii SQL brut cu EF Core?

Răspuns scurt: SQL injection apare când input-ul utilizatorului este concatenat în textul unei comenzi SQL și ajunge să fie executat ca cod. Te protejezi folosind mereu parametri: LINQ, FromSql cu interpolare (care parametrizează automat) sau SqlParameter, niciodată concatenare de string-uri.

C#
// VULNERABIL: input-ul devine parte din SQL
string nume = "x'; DROP TABLE Clienti; --";
var sql = "SELECT * FROM Clienti WHERE Nume = '" + nume + "'";
var r = db.Clienti.FromSqlRaw(sql).ToList();

Textul introdus închide ghilimelele și adaugă o comandă nouă. Atacatorul poate citi date (' OR 1=1 --), le poate modifica sau șterge.

Variantele sigure:

C#
// LINQ: mereu parametrizat
var a = await db.Clienti.Where(c => c.Nume == nume).ToListAsync();

// FromSql (EF Core 7+) sau FromSqlInterpolated: interpolarea devine parametru
var b = await db.Clienti
    .FromSql($"SELECT * FROM Clienti WHERE Nume = {nume}")
    .ToListAsync();

// FromSqlRaw cu parametri expliciți
var c = await db.Clienti
    .FromSqlRaw("SELECT * FROM Clienti WHERE Nume = {0}", nume)
    .ToListAsync();

// comenzi fără rezultat
await db.Database.ExecuteSqlAsync($"UPDATE Clienti SET Activ = 0 WHERE Id = {id}");

FromSql primește un FormattableString, deci EF Core vede separat textul și valorile și le trimite ca @p0. Capcana: dacă construiești întâi un string cu interpolare și apoi îl dai lui FromSqlRaw, parametrizarea se pierde.

Parametrii nu pot înlocui nume de tabele, coloane sau direcția de sortare. Pentru un ORDER BY dinamic, folosești o listă albă (whitelist) de coloane permise, mapate din input la nume fixe. Ca apărare suplimentară, contul aplicației în baza de date trebuie să aibă doar drepturile necesare, nu de proprietar al bazei.

Ce urmărește intervievatorul: Este o întrebare de securitate obligatorie. Capcana FromSqlRaw cu string interpolat construit înainte e exact ce verifică un intervievator atent.

78 Senior

Doi utilizatori editează aceeași comandă în același timp. Cum previi pierderea modificărilor în EF Core?

Răspuns scurt: Folosești concurență optimistă: un token de versiune (rowversion în SQL Server) care e verificat în clauza WHERE la UPDATE. Dacă altcineva a modificat rândul între timp, EF Core aruncă DbUpdateConcurrencyException, iar aplicația decide cum rezolvă conflictul.

Fără protecție apare problema lost update: A și B citesc comanda, A salvează, apoi B salvează peste și șterge modificarea lui A fără ca nimeni să afle.

Concurența optimistă pornește de la ideea că conflictele sunt rare, deci nu blochează nimic la citire, ci verifică la scriere:

C#
public class Comanda
{
    public int Id { get; set; }
    public string Status { get; set; } = "";
    [Timestamp] public byte[] Versiune { get; set; } = null!; // rowversion în SQL Server
}

La SaveChanges, EF Core generează:

SQL
UPDATE Comenzi SET Status = @p0
WHERE Id = @p1 AND Versiune = @p2;

Dacă rândul a fost modificat între timp, versiunea nu mai corespunde, se actualizează 0 rânduri, iar EF Core aruncă DbUpdateConcurrencyException:

C#
try
{
    await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException ex)
{
    var intrare = ex.Entries.Single();
    var dinBaza = await intrare.GetDatabaseValuesAsync();
    if (dinBaza is null) return NotFound();      // a fost ștearsă
    return Conflict("Comanda a fost modificată de altcineva. Reîncarcă pagina.");
}

Strategii de rezolvare: clientul câștigă (suprascrii după ce reîncarci valorile originale), baza câștigă (renunți și arăți datele noi) sau îmbinare pe câmpuri. Într-un API, versiunea se transmite clientului (de exemplu ca ETag) și se trimite înapoi la PUT, iar conflictul devine 409 sau 412.

În PostgreSQL se folosește coloana sistem xmin ca token, iar pentru orice provider poți marca o proprietate cu [ConcurrencyCheck]. Concurența pesimistă (blocări explicite, SELECT ... WITH (UPDLOCK)) e rezervată situațiilor cu conflicte frecvente și tranzacții scurte, cum ar fi rezervarea ultimului loc disponibil.

Ce urmărește intervievatorul: Întrebare de senior despre integritatea datelor. Se urmărește mecanismul concret și strategia de rezolvare a conflictului, nu doar numele.

79 Senior

O interogare EF Core este lentă. Ce optimizări ai la dispoziție și când ai trece la SQL brut sau la Dapper?

Răspuns scurt: Întâi te uiți la SQL-ul generat și la planul de execuție. Apoi aplici, după caz: proiecții, AsNoTracking, indexuri, split queries, paginare, compiled queries, operații în masă. Treci la SQL brut sau Dapper doar pentru interogări pe care LINQ nu le poate exprima eficient.

Pașii, în ordinea în care merită încercați:

  • vezi SQL-ul: query.ToQueryString() sau logarea comenzilor; multe probleme sunt evidente (SELECT pe toate coloanele, JOIN-uri inutile, N+1);
  • planul de execuție în SQL Server Management Studio sau EXPLAIN ANALYZE în PostgreSQL: scanări de tabel, index lipsă, estimări greșite;
  • proiecții în DTO-uri, ca să aduci doar coloanele necesare, și AsNoTracking pentru citiri;
  • paginare cu Skip/Take sau, pentru volume mari, keyset pagination (WHERE Id > @ultimulId), care nu degradează pe pagini îndepărtate;
  • AsSplitQuery când mai multe Include pe colecții produc explozie carteziană;
  • operații în masă cu ExecuteUpdateAsync și ExecuteDeleteAsync (EF Core 7+), în loc de încărcarea și modificarea a mii de entități;
  • compiled queries pentru interogări foarte frecvente, ca să eviți costul traducerii LINQ la fiecare apel (deși EF Core are deja un cache de interogări);
  • DbContext pooling (AddDbContextPool) pentru reducerea costului de creare a contextelor la trafic mare.
C#
private static readonly Func<AppDbContext, int, Task<Produs?>> _getProdus =
    EF.CompileAsyncQuery((AppDbContext db, int id) =>
        db.Produse.AsNoTracking().FirstOrDefault(p => p.Id == id));

var p = await _getProdus(db, 42);

SQL brut sau Dapper au sens pentru rapoarte complexe cu funcții de fereastră (ROW_NUMBER() OVER), CTE-uri recursive, hint-uri specifice motorului sau proceduri stocate existente. Dapper este un micro-ORM care doar mapează rezultatul unei comenzi SQL pe obiecte, cu overhead foarte mic. Multe proiecte combină: EF Core pentru scrieri și majoritatea citirilor, Dapper sau SqlQuery<T> (EF Core 8+) pentru câteva interogări de raportare. Decizia se ia pe baza măsurătorilor, nu din principiu.

Ce urmărește intervievatorul: Testează experiența cu performanța reală a bazelor de date. Se apreciază o ordine logică de investigare și argumentarea alegerii instrumentului.

80 Senior

Are sens să construiești un Repository pattern generic peste EF Core?

Răspuns scurt: Depinde. DbContext este deja o combinație de unit of work și repository, deci un IRepository<T> generic care doar reambalează DbSet adaugă straturi fără valoare și ascunde funcționalități. Repository-uri specifice domeniului, cu metode cu sens de business, pot fi utile pentru izolarea logicii și testare.

Un repository generic tipic arată așa:

C#
public interface IRepository<T> where T : class
{
    Task<T?> GetByIdAsync(int id);
    Task<IEnumerable<T>> GetAllAsync();
    void Add(T entity);
}

Argumente împotriva acestei variante:

  • DbSet<T> oferă deja aceste operații și multe altele;
  • GetAllAsync() întoarce IEnumerable<T> și încurajează încărcarea tabelelor întregi, filtrate apoi în memorie;
  • pierzi acces la Include, proiecții, AsNoTracking, ExecuteUpdate, sau ajungi să le reexpui pe toate, adică să reconstruiești EF Core;
  • argumentul „putem schimba ORM-ul” se materializează rar, iar abstracția oricum „scurge” comportamentul EF.

Argumente pentru repository-uri specifice:

C#
public interface IComandaRepository
{
    Task<Comanda?> GetCuLiniiAsync(int id, CancellationToken ct);
    Task<IReadOnlyList<ComandaSumarDto>> GetNeplatiteAsync(DateOnly pana, CancellationToken ct);
    void Adauga(Comanda comanda);
}
  • interogările complexe sunt definite într-un singur loc, cu nume care exprimă intenția;
  • stratul de domeniu nu depinde direct de EF Core, util în arhitecturi de tip Clean Architecture sau DDD, cu un repository per agregat;
  • serviciile se pot testa unitar cu fake-uri.

Pentru testare, alternativa la mock-uirea repository-urilor este testarea de integrare cu o bază reală (Testcontainers), care verifică și SQL-ul generat. Provider-ul InMemory nu e recomandat pentru asta, pentru că nu se comportă ca o bază relațională (tranzacții, constrângeri, traducerea interogărilor).

La interviu, un răspuns matur arată ambele perspective și spune ce ai ales într-un proiect concret și de ce.

Ce urmărește intervievatorul: E o întrebare de opinie arhitecturală. Se urmărește argumentarea echilibrată, nu un dogmatism într-o direcție sau alta.

Testare

81 Junior

Care este diferența dintre testele unitare, de integrare și end-to-end?

Răspuns scurt: Testele unitare verifică o unitate mică de cod izolat, rapid și fără dependențe externe. Testele de integrare verifică mai multe componente împreună, de exemplu API cu baza de date. Testele end-to-end verifică fluxuri întregi, ca un utilizator real, prin interfață sau API.

  • Unitare: testează o metodă sau o clasă izolată, cu dependențele înlocuite prin fake-uri. Rulează în milisecunde, deci pot fi mii, rulate la fiecare build. Exemplu: calculul discountului într-un PretService.
  • De integrare: testează colaborarea reală între componente: endpoint-ul ASP.NET Core, serializarea, EF Core și o bază de date reală (de obicei într-un container). Mai lente, dar prind erori pe care unitarele nu le văd: mapări greșite, SQL invalid, configurare de DI lipsă.
  • End-to-end (E2E): pornesc întregul sistem și simulează utilizatorul, de exemplu cu Playwright pentru interfață. Cele mai realiste, dar lente, fragile și scumpe de întreținut.

Modelul clasic este piramida testelor: multe teste unitare la bază, mai puține de integrare, câteva E2E pe fluxurile critice (autentificare, plasare comandă, plată). Unele echipe .NET preferă o formă de „romb” sau „trofeu”, cu accent pe testele de integrare pentru API-uri, pentru că WebApplicationFactory și Testcontainers le fac suficient de rapide.

MyApp.sln
  src/MyApp.Api
  src/MyApp.Domain
  tests/MyApp.Domain.UnitTests        -> xUnit, fără I/O
  tests/MyApp.Api.IntegrationTests    -> WebApplicationFactory + Testcontainers

Ce contează la interviu: să arăți că alegi tipul de test după risc. Logica de calcul complexă merită teste unitare detaliate; codul care e în principal „lipici” între HTTP și baza de date se testează mai eficient prin integrare. Un test bun eșuează doar când comportamentul e greșit, nu când refactorizezi detalii interne.

Ce urmărește intervievatorul: Întrebare de bază despre testare. Se verifică dacă știi compromisurile, nu doar definițiile.

82 Junior

Cum scrii un test unitar cu xUnit? Care e diferența dintre [Fact] și [Theory]?

Răspuns scurt: Creezi un proiect xUnit, scrii o metodă publică marcată cu [Fact] care pregătește datele, apelează codul și verifică rezultatul cu Assert. [Theory] marchează un test parametrizat, rulat pentru fiecare set de date dat prin [InlineData], [MemberData] sau [ClassData].

BASH
dotnet new xunit -n Magazin.Tests
dotnet add Magazin.Tests reference Magazin
dotnet test
C#
public class CalculatorDiscount
{
    public decimal Aplica(decimal total, string? cod) => cod switch
    {
        null or "" => total,
        "STUDENT" => total * 0.9m,
        _ => throw new ArgumentException("Cod invalid", nameof(cod))
    };
}

public class CalculatorDiscountTests
{
    private readonly CalculatorDiscount _sut = new();

    [Fact]
    public void Aplica_FaraCod_ReturneazaTotalul()
    {
        var rezultat = _sut.Aplica(100m, null);
        Assert.Equal(100m, rezultat);
    }

    [Theory]
    [InlineData(100, 90)]
    [InlineData(250, 225)]
    [InlineData(0, 0)]
    public void Aplica_CodStudent_Scade10Procente(decimal total, decimal asteptat)
    {
        Assert.Equal(asteptat, _sut.Aplica(total, "STUDENT"));
    }

    [Fact]
    public void Aplica_CodNecunoscut_AruncaExceptie()
    {
        Assert.Throws<ArgumentException>(() => _sut.Aplica(100m, "XYZ"));
    }
}

Detalii specifice xUnit:

  • se creează o instanță nouă a clasei de test pentru fiecare test, deci constructorul face setup, iar IDisposable face cleanup; nu există [SetUp] ca în NUnit;
  • pentru resurse costisitoare partajate (o bază de date) folosești IClassFixture<T> sau ICollectionFixture<T>;
  • testele din clase diferite rulează implicit în paralel;
  • numele testelor de tipul Metoda_Scenariu_Rezultat fac rapoartele lizibile.

_sut vine de la „system under test”. Alternativele populare sunt NUnit și MSTest, cu concepte similare. Multe echipe adaugă biblioteci de aserțiuni mai expresive, de exemplu Shouldly, sau FluentAssertions (atenție la licența comercială introdusă din versiunea 8).

Ce urmărește intervievatorul: Verifică dacă ai scris efectiv teste. Detaliul cu instanța nouă per test în xUnit e un bun diferențiator.

83 Junior

Ce este structura Arrange-Act-Assert și ce sunt mock-urile, stub-urile și fake-urile?

Răspuns scurt: Arrange-Act-Assert împarte testul în pregătire, execuția acțiunii testate și verificarea rezultatului. Fake-urile, stub-urile și mock-urile sunt înlocuitori ai dependențelor: stub-ul întoarce valori predefinite, mock-ul verifică și cum a fost apelat, iar fake-ul are o implementare simplificată funcțională.

Arrange-Act-Assert (AAA) face testele ușor de citit:

C#
[Fact]
public void Retrage_SumaMaiMareDecatSoldul_Arunca()
{
    // Arrange
    var cont = new Cont();
    cont.Depune(50m);

    // Act
    var act = () => cont.Retrage(100m);

    // Assert
    Assert.Throws<InvalidOperationException>(act);
    Assert.Equal(50m, cont.Sold);
}

Un test ar trebui să aibă un singur „Act” și să verifice un singur comportament. Dacă secțiunea Arrange devine uriașă, codul testat are probabil prea multe dependențe.

Test doubles (termenul general pentru înlocuitori):

  • Dummy: obiect transmis doar ca să compileze, nefolosit efectiv;
  • Stub: întoarce răspunsuri fixe („repository-ul întoarce acest client”); verifici rezultatul codului testat;
  • Mock: are așteptări despre interacțiune („emailul trebuie trimis exact o dată către această adresă”); verifici apelul;
  • Fake: implementare reală, dar simplificată, de exemplu un repository în memorie cu un Dictionary sau un FakeTimeProvider.
C#
public class FakeEmailSender : IEmailSender
{
    public List<string> Trimise { get; } = new();
    public Task TrimiteAsync(string catre, string subiect)
    {
        Trimise.Add(catre);
        return Task.CompletedTask;
    }
}

Regula practică: verifică stări și rezultate ori de câte ori poți, iar interacțiunile doar când ele sunt chiar comportamentul dorit (trimiterea unui email, publicarea unui mesaj). Testele care verifică fiecare apel intern devin fragile și se strică la orice refactorizare.

Ce urmărește intervievatorul: Se verifică vocabularul de testare și judecata despre ce merită verificat. Greșeala tipică: mock-uri pentru tot, inclusiv pentru obiecte simple de date.

84 Mid

Cum testezi un serviciu care depinde de un repository și de un serviciu de email? Arată un exemplu cu Moq sau NSubstitute.

Răspuns scurt: Injectezi dependențele prin interfețe, iar în test creezi mock-uri configurate să întoarcă date controlate. Apelezi metoda serviciului, apoi verifici rezultatul și, unde contează, că dependența a fost apelată corect, de exemplu că emailul s-a trimis o singură dată.

Serviciul testat:

C#
public class InregistrareService(IUtilizatorRepository repo, IEmailSender email)
{
    public async Task<bool> InregistreazaAsync(string adresa)
    {
        if (await repo.ExistaAsync(adresa)) return false;
        await repo.AdaugaAsync(new Utilizator(adresa));
        await email.TrimiteAsync(adresa, "Bun venit!");
        return true;
    }
}

Testele cu Moq:

C#
public class InregistrareServiceTests
{
    private readonly Mock<IUtilizatorRepository> _repo = new();
    private readonly Mock<IEmailSender> _email = new();
    private InregistrareService Sut() => new(_repo.Object, _email.Object);

    [Fact]
    public async Task EmailNou_SalveazaSiTrimiteEmail()
    {
        _repo.Setup(r => r.ExistaAsync("ana@x.ro")).ReturnsAsync(false);

        var ok = await Sut().InregistreazaAsync("ana@x.ro");

        Assert.True(ok);
        _repo.Verify(r => r.AdaugaAsync(It.Is<Utilizator>(u => u.Email == "ana@x.ro")), Times.Once);
        _email.Verify(e => e.TrimiteAsync("ana@x.ro", It.IsAny<string>()), Times.Once);
    }

    [Fact]
    public async Task EmailExistent_NuTrimiteNimic()
    {
        _repo.Setup(r => r.ExistaAsync(It.IsAny<string>())).ReturnsAsync(true);

        var ok = await Sut().InregistreazaAsync("ana@x.ro");

        Assert.False(ok);
        _email.Verify(e => e.TrimiteAsync(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
    }
}

Cu NSubstitute, sintaxa e mai concisă: repo.ExistaAsync("ana@x.ro").Returns(false); și await email.Received(1).TrimiteAsync("ana@x.ro", Arg.Any<string>());.

Observații: metodele asincrone neconfigurate dintr-un mock Moq întorc implicit un task terminat cu valoarea implicită (false, null), ceea ce poate ascunde setup-uri uitate; MockBehavior.Strict face mock-ul să arunce la apeluri neconfigurate. Mock-uiești doar interfețe pe care le controlezi tu; pentru DbContext sau HttpClient sunt mai potrivite testele de integrare sau un HttpMessageHandler fals.

Ce urmărește intervievatorul: E un exercițiu practic foarte frecvent. Se urmărește ce verifici (rezultat și interacțiuni relevante) și dacă testezi și ramura negativă.

85 Mid

Cum scrii teste de integrare pentru un API ASP.NET Core?

Răspuns scurt: Folosești WebApplicationFactory din Microsoft.AspNetCore.Mvc.Testing, care pornește aplicația în memorie și îți dă un HttpClient. Înlocuiești dependențele externe în ConfigureServices, iar pentru bază de date reală folosești de obicei Testcontainers cu o imagine Docker de SQL Server sau PostgreSQL.

WebApplicationFactory<TEntryPoint> construiește host-ul aplicației cu tot pipeline-ul real: middleware, rutare, model binding, autentificare, DI. Cererile merg printr-un server de test în memorie, fără port deschis.

C#
public class ApiFactory : WebApplicationFactory<Program>, IAsyncLifetime
{
    private readonly MsSqlContainer _db = new MsSqlBuilder().Build();

    protected override void ConfigureWebHost(IWebHostBuilder builder) =>
        builder.ConfigureServices(services =>
        {
            services.RemoveAll<DbContextOptions<AppDbContext>>();
            services.AddDbContext<AppDbContext>(o => o.UseSqlServer(_db.GetConnectionString()));
            services.AddSingleton<IEmailSender, FakeEmailSender>();
        });

    public async Task InitializeAsync()
    {
        await _db.StartAsync();
        using var scope = Services.CreateScope();
        await scope.ServiceProvider.GetRequiredService<AppDbContext>().Database.MigrateAsync();
    }

    public new Task DisposeAsync() => _db.DisposeAsync().AsTask();
}

public class ProduseApiTests(ApiFactory factory) : IClassFixture<ApiFactory>
{
    [Fact]
    public async Task Post_ApoiGet_ReturneazaProdusul()
    {
        var client = factory.CreateClient();

        var post = await client.PostAsJsonAsync("/api/produse", new { Nume = "Mouse", Pret = 90 });
        Assert.Equal(HttpStatusCode.Created, post.StatusCode);

        var get = await client.GetFromJsonAsync<ProdusDto>(post.Headers.Location);
        Assert.Equal("Mouse", get!.Nume);
    }
}

Puncte importante:

  • în minimal hosting (Program.cs fără clasă), adaugi public partial class Program { } ca testele să poată referi tipul;
  • Testcontainers (pachetul Testcontainers.MsSql) cere Docker pe mașina de test sau în CI;
  • izolarea datelor între teste: o bază per clasă, tranzacții anulate la final sau resetare cu biblioteca Respawn;
  • autentificarea se testează cu un AuthenticationHandler de test care creează un utilizator cu claims cunoscute.

Aceste teste prind exact erorile pe care unitarele nu le văd: rute greșite, serializare, migrări, configurare DI.

Ce urmărește intervievatorul: Verifică dacă știi să testezi aplicația așa cum rulează de fapt. Testcontainers și înlocuirea serviciilor sunt detaliile căutate.

86 Mid

Cum testezi cod care depinde de DateTime.Now, de numere aleatorii sau de alte dependențe nedeterministe?

Răspuns scurt: Extragi sursa de nedeterminism într-o abstracție injectată: TimeProvider (din .NET 8) pentru timp, o interfață sau un Random cu seed pentru valori aleatorii. În teste injectezi o implementare controlată, de exemplu FakeTimeProvider, care întoarce exact ora de care ai nevoie.

Codul de mai jos e greu de testat, pentru că rezultatul depinde de ora la care rulează testul:

C#
public bool EsteInPerioadaPromotiei() =>
    DateTime.Now >= new DateTime(2026, 11, 25) && DateTime.Now < new DateTime(2026, 12, 1);

Varianta testabilă cu TimeProvider (inclus în .NET 8, disponibil și ca pachet pentru versiuni mai vechi):

C#
public class PromotieService(TimeProvider timp)
{
    public bool EsteInPerioadaPromotiei()
    {
        var acum = timp.GetUtcNow();
        return acum >= new DateTimeOffset(2026, 11, 25, 0, 0, 0, TimeSpan.Zero)
            && acum <  new DateTimeOffset(2026, 12, 1, 0, 0, 0, TimeSpan.Zero);
    }
}

// Program.cs
builder.Services.AddSingleton(TimeProvider.System);

// test, cu pachetul Microsoft.Extensions.TimeProvider.Testing
[Fact]
public void InBlackFriday_PromotiaEsteActiva()
{
    var timp = new FakeTimeProvider(new DateTimeOffset(2026, 11, 27, 10, 0, 0, TimeSpan.Zero));
    var sut = new PromotieService(timp);

    Assert.True(sut.EsteInPerioadaPromotiei());

    timp.Advance(TimeSpan.FromDays(5));
    Assert.False(sut.EsteInPerioadaPromotiei());
}

FakeTimeProvider controlează și timerele și Task.Delay care primesc TimeProvider, deci poți testa logică de retry sau expirare fără să aștepți efectiv.

Același principiu se aplică pentru: numere aleatorii (injectezi un Random cu seed fix sau o interfață), generarea de Guid-uri, citirea de variabile de mediu, sistemul de fișiere (System.IO.Abstractions). Ideea comună: codul de business nu atinge direct resursele globale, ci le primește prin constructor. Bonus: folosirea orei UTC în logică evită bug-urile la trecerea la ora de vară.

Ce urmărește intervievatorul: Verifică dacă scrii cod testabil din start. Cunoașterea TimeProvider din .NET 8 arată că ești la curent.

87 Senior

Echipa are o suită de teste lentă și cu teste care pică intermitent. Ce strategie de testare ai propune?

Răspuns scurt: Măsori întâi: care teste sunt lente și care sunt instabile. Pui testele instabile în carantină și le repari la cauză (timp, ordine, date partajate, așteptări fixe), reechilibrezi tipurile de teste după risc și organizezi rularea în CI pe niveluri, cu feedback rapid.

Un plan pe care l-ai putea prezenta la interviu:

  • Date, nu impresii: rapoartele de test din CI (durata per test, rata de eșec per test pe ultimele rulări) arată unde e problema. Adesea câteva teste dau majoritatea timpului sau a eșecurilor.
  • Testele instabile (flaky): le marchezi și le scoți temporar din build-ul blocant (de exemplu cu un Trait filtrat), cu un owner și un termen de reparare. Cauzele frecvente în .NET:
  • dependența de ora reală sau de Task.Delay cu timpi fixi (soluție: TimeProvider, așteptarea unei condiții, nu a unui timp);
  • date partajate între teste care rulează în paralel (soluție: date unice per test, baze izolate, Respawn);
  • dependența de ordinea execuției sau de stare statică;
  • servicii externe reale în teste (soluție: fake-uri sau WireMock.Net).
  • Viteza: teste de integrare care pornesc un container per test se pot regrupa într-o fixtură partajată; logica pură mutată din testele E2E în teste unitare; paralelizarea pe mai mulți agenți CI.
  • Organizarea rulării: la fiecare push, teste unitare și de integrare rapide (câteva minute); suita completă și E2E la merge sau periodic.
BASH
dotnet test --filter "Category!=Lent"
dotnet test --logger "trx" --blame-hang-timeout 2m
  • Calitatea, nu procentul de acoperire: code coverage (de exemplu cu coverlet) arată zonele netestate, dar o țintă procentuală impusă produce teste fără aserțiuni utile. Mutation testing (Stryker.NET) verifică dacă testele chiar prind bug-uri.

Un detaliu de leadership: regula „un test roșu nu se ignoră” trebuie să fie credibilă, iar asta se întâmplă doar dacă testele sunt de încredere.

Ce urmărește intervievatorul: Întrebare de senior care testează gândirea la nivel de echipă. Se apreciază diagnosticarea cauzelor reale și echilibrul dintre viteză și încredere.

Git, Linux și Docker

88 Junior

Care este diferența dintre git merge și git rebase?

Răspuns scurt: Merge unește două ramuri printr-un commit de merge, păstrând istoria exact cum s-a întâmplat. Rebase mută commit-urile tale peste vârful altei ramuri, rescriindu-le, și produce o istorie liniară. Nu faci rebase pe commit-uri deja publicate și folosite de alții.

Presupunem că ai lucrat pe feature/plata, iar între timp main a avansat.

BASH
# merge: creează un commit care are doi părinți
git switch feature/plata
git merge main

# rebase: reaplică commit-urile tale peste main
git switch feature/plata
git fetch origin
git rebase origin/main
# la conflicte: rezolvi, apoi
git add .
git rebase --continue

Merge:

  • nu rescrie nimic, deci e sigur pe ramuri partajate;
  • istoria arată exact când s-au integrat ramurile;
  • cu multe ramuri, graful devine încâlcit.

Rebase:

  • istorie liniară, ușor de citit cu git log și ușor de investigat cu git bisect;
  • commit-urile primesc hash-uri noi; dacă alții au deja vechile commit-uri, istoriile lor diverg;
  • după un rebase pe o ramură deja publicată, trebuie git push --force-with-lease, mai sigur decât --force, pentru că refuză suprascrierea dacă altcineva a împins între timp.

Regula de aur: rebase pe ramura ta locală sau personală, merge pentru integrarea în ramurile comune. git rebase -i este util înainte de un pull request, ca să unești commit-uri de tip „fix typo” într-o istorie curată.

Multe echipe aleg strategia la nivel de pull request pe GitHub sau Azure DevOps: merge commit, squash merge (toate commit-urile din PR devin unul singur) sau rebase merge. Merită să știi ce folosea echipa ta și de ce.

Ce urmărește intervievatorul: Este întrebarea Git clasică. Se verifică dacă știi riscul rescrierii istoriei publice și --force-with-lease.

89 Junior

Descrie fluxul tău zilnic cu Git într-o echipă: de la un task nou până la codul ajuns în main. Cum rezolvi un conflict?

Răspuns scurt: Creezi o ramură din main actualizat, faci commit-uri mici cu mesaje clare, împingi ramura, deschizi un pull request, treci de review și de pipeline-ul CI, apoi se face merge. La conflict, aduci ultimele modificări, rezolvi manual fișierele marcate, rulezi testele și continui.

Un flux tipic, de tip GitHub Flow sau trunk-based:

BASH
git switch main
git pull
git switch -c feature/1234-export-csv

# lucru, commit-uri mici și coerente
git add src/Export/CsvExporter.cs
git commit -m "Adaugă export CSV pentru comenzi"

git push -u origin feature/1234-export-csv
# deschizi pull request-ul, legat de task

În pull request: o descriere a schimbării și a modului de testare, pipeline-ul CI rulează dotnet build și dotnet test, colegii fac code review, tu răspunzi la comentarii cu commit-uri noi. După aprobare, se face merge (adesea squash), iar ramura se șterge.

Rezolvarea unui conflict: apare când tu și altcineva ați modificat aceleași linii.

BASH
git fetch origin
git merge origin/main        # sau git rebase origin/main
# Git marchează fișierele în conflict
git status

În fișier apar markerii:

<<<<<<< HEAD
var taxa = total * 0.19m;
=======
var taxa = _calculatorTaxe.Calculeaza(total);
>>>>>>> origin/main

Nu alegi mecanic o parte: înțelegi intenția ambelor modificări (aici, colegul a mutat calculul într-un serviciu, deci probabil păstrezi varianta lui și adaptezi codul tău). Elimini markerii, compilezi, rulezi testele, apoi git add și git commit (sau git rebase --continue). Pentru conflicte mari, un tool vizual (Visual Studio, Rider, VS Code) ajută.

Bune practici: sincronizează-te des cu main, ca să ai conflicte mici; nu face commit la fișiere generate (bin/, obj/), ține-le în .gitignore.

Ce urmărește intervievatorul: Se verifică dacă ai lucrat efectiv într-o echipă. Intervievatorul vrea să audă că rezolvi conflictul înțelegând intenția și că rulezi testele după.

90 Junior

Aplicația ta .NET rulează pe un server Linux și nu răspunde. Ce comenzi folosești ca să investighezi?

Răspuns scurt: Verifici dacă procesul rulează (systemctl status, ps), dacă ascultă pe port (ss), ce spun logurile (journalctl, tail), dacă serverul are resurse (top, df, free) și dacă endpoint-ul răspunde local (curl). Apoi folosești uneltele .NET de diagnostic dacă procesul e blocat.

O succesiune logică de comenzi:

BASH
# 1. rulează serviciul?
systemctl status myapi
ps aux | grep -i myapi

# 2. ce spun logurile?
journalctl -u myapi -n 200 --no-pager
tail -f /var/log/myapi/app.log

# 3. ascultă aplicația pe port?
ss -tlnp | grep 5000

# 4. răspunde local, ocolind proxy-ul?
curl -v http://localhost:5000/health

# 5. resursele serverului
top            # CPU și memorie per proces
free -h        # memorie liberă
df -h          # disc plin? logurile pot umple discul

# 6. permisiuni și configurare
ls -l /var/www/myapi
cat /etc/systemd/system/myapi.service

Cum interpretezi rezultatele:

  • serviciul s-a oprit: logurile arată de obicei excepția de la pornire (connection string greșit, port ocupat, fișier lipsă, permisiuni);
  • procesul rulează, dar portul nu e deschis: verifici ASPNETCORE_URLS sau configurarea Kestrel;
  • curl local merge, dar din exterior nu: problema e la Nginx, la firewall (ufw status) sau la DNS;
  • procesul consumă 100% CPU sau nu răspunde deloc: dotnet-counters monitor -p <pid> arată thread pool-ul și GC-ul, iar dotnet-dump collect -p <pid> îți permite să vezi stack-urile tuturor thread-urilor (comanda clrstack -all în dotnet-dump analyze), ca să găsești un deadlock;
  • discul plin: du -sh /var/log/* arată ce ocupă spațiu.

Permisiunile contează des: un serviciu care rulează ca utilizatorul www-data nu poate citi fișiere deținute de root cu chmod 600. Comenzile chown și chmod rezolvă problema, fără să rulezi aplicația ca root.

Ce urmărește intervievatorul: Verifică familiaritatea cu Linux în producție și o metodă ordonată de lucru. Mulți dezvoltatori .NET au lucrat doar pe Windows.

91 Junior

Scrie un Dockerfile pentru un API ASP.NET Core. De ce se folosește un build multi-stage?

Răspuns scurt: Primul stage folosește imaginea SDK ca să restaureze pachetele, să compileze și să publice aplicația; al doilea pornește din imaginea mai mică de runtime ASP.NET și copiază doar rezultatul publicării. Imaginea finală e mai mică și are o suprafață de atac redusă.

# stage 1: build
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src

COPY ["MyApi/MyApi.csproj", "MyApi/"]
RUN dotnet restore "MyApi/MyApi.csproj"

COPY . .
RUN dotnet publish "MyApi/MyApi.csproj" -c Release -o /app/publish /p:UseAppHost=false

# stage 2: runtime
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS final
WORKDIR /app
COPY --from=build /app/publish .
USER app
EXPOSE 8080
ENTRYPOINT ["dotnet", "MyApi.dll"]

De ce e scris așa:

  • multi-stage: SDK-ul (compilator, unelte, cache NuGet) e necesar doar la build; imaginea aspnet conține doar runtime-ul, deci e mult mai mică și nu include unelte de care un atacator ar putea profita;
  • copierea .csproj și restore înaintea restului codului folosește cache-ul de straturi Docker: dacă modifici doar cod C#, nu dependențe, pasul de restore nu se mai execută;
  • portul 8080 și USER app: din .NET 8, imaginile oficiale ascultă implicit pe 8080 și includ un utilizator neprivilegiat app, deci containerul nu rulează ca root;
  • un fișier .dockerignore cu bin/, obj/ și .git reduce contextul trimis la build și evită copierea artefactelor locale.
BASH
docker build -t myapi:1.0 .
docker run -d -p 8080:8080 -e ConnectionStrings__Db="..." --name myapi myapi:1.0
docker logs -f myapi

Configurarea specifică mediului (connection string-uri, chei) se dă prin variabile de mediu la rulare, nu se copiază în imagine. Pentru imagini și mai mici există variantele -alpine sau -chiseled (Ubuntu minimalist), iar din .NET 7 SDK-ul poate construi imagini și fără Dockerfile, cu dotnet publish /t:PublishContainer.

Ce urmărește intervievatorul: Verifică experiența practică cu containerizarea aplicațiilor .NET. Ordinea COPY pentru cache și rularea fără root sunt detaliile apreciate.

92 Mid

Cum rulezi local API-ul împreună cu SQL Server folosind Docker Compose? Cum păstrezi datele între reporniri?

Răspuns scurt: Definești în docker-compose.yml două servicii, api și db, într-o rețea comună, unde API-ul se conectează la baza de date folosind numele serviciului ca host. Datele SQL Server se păstrează într-un volum numit, care supraviețuiește opririi și ștergerii containerului.

YAML
services:
  db:
    image: mcr.microsoft.com/mssql/server:2022-latest
    environment:
      ACCEPT_EULA: "Y"
      MSSQL_SA_PASSWORD: ${SA_PASSWORD}
    ports:
      - "1433:1433"
    volumes:
      - sqldata:/var/opt/mssql
    healthcheck:
      test: ["CMD-SHELL", "/opt/mssql-tools18/bin/sqlcmd -S localhost -U sa -P \"$$MSSQL_SA_PASSWORD\" -C -Q 'SELECT 1' || exit 1"]
      interval: 10s
      retries: 10

  api:
    build: .
    ports:
      - "8080:8080"
    environment:
      ConnectionStrings__Db: "Server=db;Database=Magazin;User Id=sa;Password=${SA_PASSWORD};TrustServerCertificate=True"
    depends_on:
      db:
        condition: service_healthy

volumes:
  sqldata:
BASH
docker compose up -d --build
docker compose logs -f api
docker compose down        # păstrează volumul
docker compose down -v     # șterge și datele

Puncte cheie:

  • imagine vs container: imaginea este șablonul imuabil; containerul este o instanță care rulează, cu propriul strat de scriere, pierdut la ștergerea containerului;
  • volumele stochează datele în afara stratului containerului, deci baza rămâne după down și up;
  • în rețeaua creată de Compose, serviciile se găsesc după nume, de aceea Server=db, nu localhost; în container, localhost înseamnă containerul însuși;
  • depends_on simplu doar ordonează pornirea; cu condition: service_healthy API-ul așteaptă ca SQL Server să accepte efectiv conexiuni;
  • parola vine dintr-un fișier .env neversionat, nu e scrisă în YAML.

Chiar și cu healthcheck, aplicația ar trebui să reîncerce conexiunea la pornire (EF Core are EnableRetryOnFailure pentru SQL Server), pentru că în producție baza poate deveni temporar indisponibilă.

Ce urmărește intervievatorul: Verifică dacă înțelegi rețelele și persistența în Docker. Greșeala clasică: localhost în connection string-ul din container.

93 Mid

Cum ar arăta un pipeline CI/CD pentru o aplicație .NET?

Răspuns scurt: La fiecare push sau pull request, pipeline-ul restaurează pachetele, compilează, rulează testele și analiza de cod, apoi publică un artefact sau o imagine Docker. La merge în main, același artefact este livrat automat într-un mediu de test și, după verificări, în producție.

Exemplu cu GitHub Actions (conceptele sunt aceleași în Azure DevOps sau GitLab CI):

YAML
name: ci
on:
  pull_request:
  push:
    branches: [main]

jobs:
  build-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: "8.0.x"
      - run: dotnet restore
      - run: dotnet build --no-restore -c Release
      - run: dotnet test --no-build -c Release --logger trx
      - run: dotnet format --verify-no-changes

  docker:
    needs: build-test
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: docker build -t registry.exemplu.ro/myapi:${{ github.sha }} .
      # push în registry, apoi deploy în staging

Principii de discutat:

  • build o singură dată, livrezi același artefact în toate mediile; diferă doar configurarea, dată prin variabile de mediu sau secrete;
  • porțile de calitate pe pull request: build, teste, formatare, analizoare (TreatWarningsAsErrors pentru avertismente importante), eventual scanare de vulnerabilități în pachete cu dotnet list package --vulnerable;
  • migrările bazei de date rulate ca pas separat, controlat, cu scripturi idempotente sau bundle-uri EF;
  • secretele stau în managerul de secrete al platformei CI, nu în YAML;
  • deploy progresiv: staging, smoke tests, apoi producție, eventual cu aprobare manuală, blue-green sau canary;
  • rollback rapid: imagini versionate după hash-ul commit-ului, deci revii la versiunea anterioară schimbând doar tag-ul.

Feedback-ul rapid contează: un pipeline de PR care durează peste câteva minute ajunge să fie ocolit de echipă.

Ce urmărește intervievatorul: Se verifică dacă vezi întreg drumul codului până în producție. Ideea „build once, deploy many” e cea mai apreciată.

Comportamentale și HR

94 Junior

Spune-ne câteva lucruri despre tine și de ce ai ales C# și .NET.

Răspuns scurt: Un răspuns bun durează unul sau două minute: cine ești profesional, ce ai construit relevant pentru post, de ce .NET te atrage concret și ce cauți în rolul acesta. Legi fiecare punct de cerințele anunțului.

Întrebarea pare banală, dar dă tonul interviului. Intervievatorul nu vrea biografia completă, ci un rezumat orientat spre post. Structură recomandată: prezent, trecut, viitor.

  • Prezent: ce faci acum. „Lucrez de un an ca developer junior pe un API ASP.NET Core pentru gestiunea comenzilor” sau, dacă ești la început, „Am terminat un program de pregătire pe C# și .NET și am construit două proiecte complete”.
  • Trecut: una sau două experiențe relevante, cu rezultat concret. „Am construit un API cu EF Core și SQL Server, cu autentificare JWT, teste xUnit și deploy în Docker; codul e pe GitHub.” Dacă vii din altă meserie, leagă experiența de programare: lucrul cu date, procese, clienți.
  • Viitor: de ce postul acesta. „Caut o echipă în care să lucrez pe un produs .NET în producție și să învăț de la colegi mai experimentați despre arhitectură și performanță.”

Pentru „de ce .NET”, dă motive reale, nu generice:

  • limbaj tipizat static, cu unelte foarte bune (Visual Studio, Rider, analizoare) care prind greșeli devreme;
  • un ecosistem complet: web, cloud, desktop, mobile, jocuri cu Unity;
  • platformă open source și cross-platform, cu performanță bună în aplicații web;
  • cerere constantă pe piață pentru aplicații enterprise și pentru proiecte în cloud, în special în Azure.

De evitat: un monolog de cinci minute, recitarea CV-ului, „îmi place să programez” fără exemple, critici la adresa angajatorului actual. Exersează răspunsul cu voce tare până sună natural, nu memorat.

Ce urmărește intervievatorul: Se verifică claritatea comunicării și motivația. Greșeala tipică: un răspuns fără legătură cu postul sau prea lung.

95 Junior

Povestește despre un bug greu pe care l-ai rezolvat.

Răspuns scurt: Folosește structura STAR: situația, sarcina ta, acțiunile concrete și rezultatul. Accentul cade pe cum ai gândit: ce ipoteze ai avut, cum le-ai verificat, ce unelte ai folosit și ce ai schimbat ca problema să nu reapară.

Intervievatorul vrea să vadă cum depanezi, nu cât de spectaculos a fost bug-ul. Structura STAR te ajută să fii concis:

  • Situația: contextul în una sau două fraze. „Într-un API ASP.NET Core, unele cereri pentru lista de comenzi durau ocazional peste 30 de secunde, doar în producție.”
  • Sarcina: ce rol ai avut. „Am primit tichetul și trebuia să găsesc cauza fără să afectez utilizatorii.”
  • Acțiunile, partea cea mai importantă, cu pași concreți:
  • „Am corelat logurile după TraceId și am văzut că timpul se ducea pe o singură interogare SQL.”
  • „Am activat logarea SQL din EF Core în staging și am observat că, pentru unii clienți, se făceau sute de interogări: N+1 pe liniile comenzii, vizibil doar la clienții cu multe comenzi.”
  • „Am înlocuit încărcarea cu o proiecție în DTO și am adăugat un index pe ClientId.”
  • Rezultatul: măsurabil și verificabil. „Endpoint-ul a coborât sub o secundă pentru toți clienții; am adăugat un test de integrare care numără interogările și o alertă pe latența p95.”

Ce face un răspuns bun:

  • ipoteze formulate și verificate, nu încercări la întâmplare;
  • unelte concrete: debugger, loguri, profiler, git bisect, reproducere cu un test;
  • o lecție și o măsură de prevenire.

Pregătește dinainte două povești reale, una tehnică și una cu componentă de colaborare. Dacă ești la început, un bug din proiectul personal e perfect valid, cât timp e real și îl poți explica în detaliu. Nu inventa: întrebările de aprofundare dau ușor de gol o poveste construită.

Ce urmărește intervievatorul: Este una dintre cele mai frecvente întrebări comportamentale tehnice. Se verifică metoda de depanare și onestitatea.

96 Junior

Prezintă un proiect de care ești mândru. Ce ai face diferit acum?

Răspuns scurt: Alege un proiect relevant pentru post, explică problema rezolvată, arhitectura și contribuția ta concretă, apoi o decizie tehnică argumentată. Încheie cu ce ai îmbunătăți acum: arată că ai evoluat și că înțelegi compromisurile.

Pentru un junior, proiectul poate fi personal, din facultate, dintr-un curs sau de la primul job. Ce contează e să-l cunoști în profunzime. Structură:

  • Problema: pentru cine e și ce rezolvă. „O aplicație de programări pentru un cabinet, unde clienții își rezervă singuri intervalul.”
  • Arhitectura, pe scurt: „API ASP.NET Core 8 cu minimal APIs, EF Core cu PostgreSQL, autentificare JWT, frontend separat, totul rulat cu Docker Compose și deploy pe un VPS.”
  • Contribuția ta: la un proiect de echipă, spune clar ce ai făcut tu. Folosește „eu” pentru părțile tale.
  • O decizie tehnică explicată: „Am folosit concurență optimistă cu un token de versiune pe intervale, ca doi clienți să nu poată rezerva același loc; am testat scenariul cu un test de integrare care trimite două cereri simultan.”
  • Rezultatul: utilizatori reali, timp economisit, ce ai învățat.

Partea „ce ai face diferit” e la fel de importantă. Exemple de răspunsuri mature:

  • „Aș scrie teste de integrare de la început; le-am adăugat târziu și am găsit bug-uri vechi.”
  • „Am pus prea multă logică în endpoint-uri; acum aș muta-o în servicii testabile.”
  • „Aș configura logging structurat și un health check de la prima zi.”

Pregătește-te pentru întrebări de aprofundare: de ce ai ales PostgreSQL, cum ai gestionat secretele, ce se întâmplă dacă cad doi clienți pe același interval, cum ai scala aplicația. Ține codul pe GitHub curat, cu un README care explică rularea locală, pentru că mulți intervievatori se uită înainte de interviu.

Ce urmărește intervievatorul: Se verifică profunzimea reală a experienței și capacitatea de autocritică. Răspunsul slab descrie funcționalități fără decizii tehnice.

97 Junior

Cum înveți o tehnologie nouă? Dă un exemplu recent.

Răspuns scurt: Descrie un proces concret: documentația oficială pentru concepte, un proiect mic aplicat, citirea codului sau a exemplelor existente, apoi feedback de la colegi. Susține-l cu un exemplu real, cu durată și rezultat, de preferat legat de ecosistemul .NET.

În .NET apare o versiune nouă în fiecare an, iar proiectele combină multe tehnologii: EF Core, Docker, cloud, cozi de mesaje. Intervievatorul vrea să știe dacă poți deveni productiv singur, într-un timp rezonabil.

Un proces credibil:

  • înțelegi întâi de ce există tehnologia și ce problemă rezolvă; documentația oficială (Microsoft Learn pentru .NET) e de obicei punctul de plecare;
  • construiești ceva mic, dar real, nu doar parcurgi tutoriale: un endpoint, un test, un container;
  • compari cu ce știi deja, ca să înțelegi modelul mental: „IAsyncEnumerable e ca un IEnumerable, dar fiecare element poate fi așteptat”;
  • citești cod existent din proiectul echipei sau exemple oficiale;
  • ceri feedback devreme, printr-un pull request mic sau o discuție cu un coleg.

Exemplu structurat:

„Când echipa a decis să scrie teste de integrare cu Testcontainers, nu lucrasem cu Docker în teste. Am citit documentația, am făcut într-o după-amiază un proiect demo cu un API și SQL Server în container, apoi am scris primul test real pentru endpoint-ul de comenzi. L-am prezentat echipei într-un PR mic, am primit sugestia să partajăm containerul între teste cu un ICollectionFixture, ceea ce a redus timpul de rulare. Acum toate testele noi de API folosesc modelul acesta.”

Ce să eviți: „mă uit pe YouTube” fără niciun proces, sau pretenția că înveți orice în două zile. E în regulă să spui că o tehnologie complexă îți ia săptămâni ca să o stăpânești bine; arată doar că ai un plan.

Ce urmărește intervievatorul: Verifică autonomia și curiozitatea. Un exemplu concret, cu pași și rezultat, valorează mai mult decât declarațiile generale.

98 Mid

Ai primit într-un code review comentarii cu care nu ești de acord. Cum procedezi?

Răspuns scurt: Pornești de la ideea că reviewer-ul vrea același lucru ca tine: cod bun. Clarifici ce a vrut să spună, argumentezi tehnic cu exemple sau măsurători, propui o discuție scurtă dacă firul se lungește și accepți decizia echipei, chiar dacă e diferită de varianta ta.

Code review-ul este locul unde apar cele mai multe dezacorduri tehnice. Intervievatorul verifică dacă poți colabora fără orgoliu, dar și fără să cedezi la orice.

Un mod de lucru structurat:

  • Separi persoana de cod: comentariul e despre pull request, nu despre tine.
  • Te asiguri că ai înțeles: „Te referi la faptul că ToList() aduce toate rândurile înainte de filtrare?” Multe dezacorduri sunt neînțelegeri.
  • Argumentezi cu fapte: documentație, un benchmark mic cu BenchmarkDotNet, un test care demonstrează comportamentul, convențiile existente în proiect.
  • Distingi preferința de problemă: stilul (var sau tip explicit) ar trebui să fie decis de .editorconfig și de analizoare, nu de discuții repetate. Corectitudinea, securitatea și performanța merită discutate în detaliu.
  • Muți discuția într-un apel scurt dacă firul de comentarii trece de două-trei schimburi.
  • Accepți decizia și mergi mai departe; dacă subiectul e important, propui să fie discutat la nivel de echipă și notat în ghidul de cod.

Exemplu de răspuns STAR: „Un coleg senior mi-a cerut să înlocuiesc o proiecție LINQ cu un repository generic. Am întrebat ce problemă voia să rezolve; voia consecvență cu restul codului. I-am arătat că varianta generică aducea entitățile întregi și am măsurat diferența pe un set realist de date. Am convenit să păstrăm proiecția și să adăugăm o metodă specifică în repository-ul existent. Discuția a dus la o regulă scrisă în ghidul echipei.”

La fel de important este reversul: când tu faci review, scrie comentarii concrete, explică de ce și separă clar blocantele de sugestii.

Ce urmărește intervievatorul: Se urmărește maturitatea în colaborare. Răspunsurile extreme, „fac ce zice seniorul” sau „îmi susțin varianta până la capăt”, sunt semnale negative.

99 Mid

Ți se cere să livrezi o funcționalitate într-un termen pe care îl consideri nerealist. Ce faci?

Răspuns scurt: Nu accepți în tăcere și nici nu refuzi direct. Spargi munca în bucăți estimabile, explici riscurile și propui opțiuni concrete: reducerea scopului, livrare în etape, mai multe resurse sau un termen mutat, lăsând decizia celor care stabilesc prioritățile.

Intervievatorul vrea să vadă dacă știi să estimezi, să comunici devreme și să negociezi constructiv. Un răspuns bun are câțiva pași:

  • Înțelegi de ce există termenul: o lansare comercială, o obligație legală, o demonstrație pentru un client? Asta schimbă ce se poate negocia.
  • Spargi funcționalitatea în sarcini mici și le estimezi, incluzând ce se uită de obicei: teste, migrări de bază de date, code review, deploy, documentație.
  • Faci vizibile riscurile: integrare cu un API extern nedocumentat, date de migrat, dependența de altă echipă.
  • Propui opțiuni, nu doar o problemă:
  • un MVP cu partea esențială până la termen, restul într-o etapă următoare;
  • renunțarea temporară la funcționalități secundare, de exemplu export PDF;
  • ajutor de la un coleg pe o parte izolabilă;
  • mutarea termenului, cu o dată argumentată.
  • Comunici devreme și periodic: o problemă semnalată în prima zi e o discuție; semnalată în ultima zi e o criză.

Ce nu faci: nu sacrifici în tăcere testele și calitatea ca să „prinzi” termenul, pentru că datoria tehnică se plătește oricum, de obicei sub forma unor bug-uri în producție.

Exemplu scurt: „Pentru un modul de facturare, termenul era de o săptămână. Am descompus munca și am estimat aproape trei. Am propus livrarea în prima săptămână doar a generării facturilor standard, cu stornările și exportul în etapa a doua. Product owner-ul a acceptat, pentru că acoperea majoritatea cazurilor, iar restul a fost livrat după două săptămâni, fără incidente.”

Ce urmărește intervievatorul: Verifică maturitatea profesională și comunicarea cu partea de business. Greșeala tipică: „lucrez peste program și gata”.

100 Mid

Povestește despre o greșeală pe care ai făcut-o și care a ajuns în producție. Cum ai gestionat-o?

Răspuns scurt: Alege o greșeală reală, cu impact moderat. Explică pe scurt ce s-a întâmplat, cum ai reacționat imediat (comunicare, rollback sau hotfix), cum ai găsit cauza și ce ai schimbat în proces ca să nu se repete. Asumarea contează mai mult decât greșeala.

Toți dezvoltatorii cu experiență au introdus bug-uri în producție. Intervievatorul verifică trei lucruri: dacă îți asumi, cum reacționezi sub presiune și dacă înveți la nivel de proces, nu doar personal.

Structură recomandată:

  • Ce s-a întâmplat, fără dramatizare și fără să dai vina pe alții: „Am adăugat o migrare EF Core care redenumea o coloană. Generatorul a interpretat-o ca ștergere și adăugare, iar eu nu am verificat codul migrării. În staging tabelul era gol, deci nu s-a observat.”
  • Reacția imediată: „Am observat în monitorizare erori la câteva minute după deploy, am anunțat echipa pe canalul de incidente și am oprit pipeline-ul. Am restaurat coloana din backup-ul de dinaintea deploy-ului, împreună cu un coleg de la operațiuni.”
  • Analiza cauzei: de ce a fost posibil? Migrarea nu fusese citită în review, iar staging nu avea date realiste.
  • Măsurile de prevenire: „Am propus ca migrările să fie verificate explicit în pull request, sub forma scriptului SQL generat, și ca staging să fie populat cu date anonimizate. Am scris în ghidul echipei cum se face corect o redenumire.”

Un post-mortem bun este fără vinovați (blameless): se concentrează pe ce a permis greșeala, nu pe cine a făcut-o.

Ce să eviți:

  • „nu am făcut niciodată o greșeală în producție” sună fie neadevărat, fie a lipsă de experiență;
  • o greșeală catastrofală prezentată lejer;
  • o poveste în care vina e a testerului, a managerului sau a cerințelor.

Dacă nu ai lucrat încă în producție, folosește o greșeală dintr-un proiect de echipă sau personal și aplică aceeași structură.

Ce urmărește intervievatorul: Întrebarea testează asumarea responsabilității și învățarea din greșeli. Lipsa unei măsuri de prevenire face răspunsul incomplet.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru Developer C# / .NET

← 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 Developer C# / .NET, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de Developer C# / .NET

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.