...
Pregătire interviuri

100 de întrebări de interviu C#, cu răspunsuri

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

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

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 150 minde citit
Întrebări de interviu C# cu răspunsuri

La un interviu pentru un post de C# sau .NET, limbajul în sine este verificat aproape întotdeauna separat de framework-uri. Pe lângă întrebările de teorie (tipuri valoare și referință, interfețe, generice, excepții), intervievatorii folosesc des fragmente scurte de cod de tipul „ce afișează?” sau „unde e bug-ul?”, un exercițiu de programare live (de exemplu prelucrarea unui text sau o interogare LINQ pe o listă de obiecte) și, uneori, o temă de casă urmată de o discuție despre deciziile tale. Scopul este să vadă dacă înțelegi ce face codul, nu doar dacă știi sintaxa.

La nivel junior se verifică fundamentele: împărțirea întreagă, conversiile, string, clasele și proprietățile, colecțiile de bază, LINQ simplu, try/catch și primii pași cu async/await. La nivel mid, întrebările trec la consecințe: contractul dintre Equals și GetHashCode, closure-uri, evaluarea amânată și costul operațiilor pe colecții, propagarea excepțiilor în cod asincron, boxing. Întrebările de nivel senior ating detalii de runtime și performanță: copii defensive la struct-uri, Span<T>, pool-uri de memorie, concurență cu limită. ASP.NET Core și Entity Framework Core sunt tratate pe pagina dedicată meseriei de .NET Developer; aici rămânem la limbaj.

Fiecare întrebare are un răspuns scurt, de spus în primele secunde, un răspuns detaliat cu cod și o notă despre ce urmărește intervievatorul. Încearcă întâi să răspunzi singur, apoi compară. Rulează exemplele într-un proiect dotnet new console pe .NET 8 sau mai nou și modifică-le până înțelegi de ce se comportă așa (într-un Program.cs cu top-level statements, declarațiile de clase, struct-uri și enum-uri trebuie mutate după instrucțiuni sau într-un fișier separat); la întrebările de situație, adaptează modelul de răspuns la propriile experiențe.

Tipuri, operatori și conversii

1 Junior

Ce afișează codul următor?

C#
Console.WriteLine(7 / 2);
Console.WriteLine(7 / 2.0);
Console.WriteLine(-7 / 2);
Console.WriteLine(-7 % 3);
Console.WriteLine(7 % -3);

Răspuns scurt: Afișează 3, 3.5 (sau 3,5 în cultura română), -3, -1 și 1. Împărțirea între întregi trunchiază spre zero, iar restul are semnul deîmpărțitului.

Când ambii operanzi sunt int, operatorul / face împărțire întreagă: rezultatul exact 3,5 este trunchiat spre zero, deci 7 / 2 dă 3, iar -7 / 2 dă -3, nu -4. Mulți candidați presupun rotunjire în jos (ca în Python, unde -7 // 2 este -4), dar C# taie pur și simplu partea zecimală.

Dacă măcar un operand este double, operația se face în virgulă mobilă: 7 / 2.0 este 3,5. Atenție la afișare: Console.WriteLine folosește cultura curentă, așa că pe un sistem configurat în română vei vedea 3,5, iar pe unul în engleză 3.5.

Operatorul % întoarce restul, iar semnul rezultatului urmează deîmpărțitul (operandul din stânga):

  • -7 % 3 este -1, pentru că -7 = 3 * (-2) + (-1)
  • 7 % -3 este 1, pentru că 7 = (-3) * (-2) + 1

Consecința practică: testul de paritate n % 2 == 1 eșuează pentru numere negative impare, unde restul este -1. Varianta corectă este n % 2 != 0. Dacă ai nevoie de un rest mereu pozitiv (de exemplu pentru indici circulari), folosește ((n % m) + m) % m.

Ca să obții împărțire zecimală din două variabile int, convertește una dintre ele: (double)a / b. Scrierea (double)(a / b) este greșită, pentru că împărțirea întreagă se face înainte de conversie.

Ce urmărește intervievatorul: Verifică dacă știi regulile aritmeticii pe întregi. Greșeala tipică este (double)(a / b) sau testul de paritate cu == 1 care pică la numere negative.

2 Junior

Ce afișează Console.WriteLine(0.1 + 0.2 == 0.3); și când folosești decimal în loc de double?

Răspuns scurt: Afișează False, pentru că 0,1 și 0,2 nu se pot reprezenta exact în binar. Pentru bani și calcule care trebuie să fie exacte în baza 10 folosești decimal.

double (și float) sunt numere în virgulă mobilă binare, după standardul IEEE 754. Valori ca 0,1 au în baza 2 o reprezentare infinită, la fel cum 1/3 are în baza 10, deci se stochează o aproximare. Suma 0.1 + 0.2 dă de fapt 0.30000000000000004, așa că egalitatea cu 0.3 este falsă.

C#
Console.WriteLine(0.1 + 0.2 == 0.3);      // False
Console.WriteLine(0.1m + 0.2m == 0.3m);   // True
Console.WriteLine(Math.Abs(0.1 + 0.2 - 0.3) < 1e-9); // True

decimal (sufixul m) folosește 128 de biți și reprezintă numerele în baza 10, cu 28–29 cifre semnificative. Valori precum 0,1 sunt exacte, ceea ce îl face potrivit pentru bani, prețuri, dobânzi, orice valoare pe care un om o verifică cu calculatorul. Prețul plătit: operațiile sunt mult mai lente decât pe double (care e calculat direct de procesor) și intervalul de valori este mai mic.

Reguli practice:

  • decimal pentru sume de bani și valori contabile
  • double pentru măsurători, științifice, grafică, statistici, unde o eroare minusculă nu contează
  • nu compara niciodată două double cu ==; folosește o toleranță (epsilon) potrivită domeniului
  • float doar când contează memoria (de exemplu tablouri mari pentru grafică)

Atenție și la amestec: nu poți aduna direct decimal cu double fără conversie explicită, tocmai ca să nu pierzi precizie fără să observi.

Ce urmărește intervievatorul: Intervievatorul vrea să audă de ce apare eroarea, nu doar „decimal e mai precis”. Greșeala tipică este calculul de prețuri în double și compararea cu ==.

Eroarea, în practică:CS0664: use an 'M' suffix (decimal literal)

3 Junior

Ce se întâmplă când rulezi codul următor? Cum ai detecta depășirea?

C#
int x = int.MaxValue;
x = x + 1;
Console.WriteLine(x);

Răspuns scurt: Afișează -2147483648: în mod implicit aritmetica pe întregi nu verifică depășirea, iar valoarea „dă ocol”. Cu un bloc checked sau cu opțiunea de proiect corespunzătoare primești OverflowException.

int are 32 de biți cu semn, deci valoarea maximă este 2.147.483.647. Adunarea lui 1 produce în reprezentarea în complement față de doi cel mai mic int, adică -2.147.483.648. În mod implicit, C# compilează aritmetica pe întregi în context unchecked, pentru performanță, așa că nu primești nicio eroare: doar un rezultat greșit.

Ca să detectezi depășirea:

C#
int x = int.MaxValue;
try
{
    int y = checked(x + 1);
}
catch (OverflowException)
{
    Console.WriteLine("Depășire!");
}

checked
{
    long total = 0;
    // toate operațiile din bloc sunt verificate
}

Poți activa verificarea pentru tot proiectul cu <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow> în .csproj, apoi folosești unchecked explicit acolo unde depășirea este intenționată (de exemplu la calculul unui hash).

Câteva detalii care apar la interviu:

  • expresiile constante sunt verificate la compilare: int y = int.MaxValue + 1; dă eroarea CS0220
  • decimal aruncă mereu OverflowException, indiferent de context
  • double nu aruncă: ajunge la Infinity
  • Enumerable.Sum pe int folosește aritmetică verificată și aruncă excepție

În practică, dacă valorile pot crește mult (sume, contoare, milisecunde), alegi din start long sau decimal în loc să te bazezi pe verificări.

Ce urmărește intervievatorul: Verifică înțelegerea limitelor tipurilor numerice. Mulți candidați cred că C# aruncă automat excepție la depășire, ca în unele limbaje dinamice.

Eroarea, în practică:OverflowException: too large or too small for Int32CS0220: The operation overflows at compile time

4 Junior

Ce afișează fiecare linie?

C#
Console.WriteLine((int)3.9);
Console.WriteLine((int)-3.9);
Console.WriteLine(Convert.ToInt32(3.5));
Console.WriteLine(Convert.ToInt32(4.5));
Console.WriteLine(Math.Round(2.5));
Console.WriteLine(Math.Round(2.5, MidpointRounding.AwayFromZero));

Răspuns scurt: Afișează 3, -3, 4, 4, 2 și 3. Cast-ul trunchiază spre zero, iar Convert.ToInt32 și Math.Round folosesc implicit rotunjirea bancherului: la jumătate, spre numărul par.

Sunt trei comportamente diferite pe care candidații le confundă des.

Cast-ul explicit (int) aruncă partea zecimală, adică trunchiază spre zero: 3,9 devine 3, iar -3,9 devine -3. Nu rotunjește.

Convert.ToInt32(double) rotunjește, dar folosește rotunjirea bancherului (MidpointRounding.ToEven): o valoare aflată exact la jumătate merge spre cel mai apropiat număr par. Așa că 3,5 devine 4, iar 4,5 devine tot 4.

Math.Round are aceeași regulă implicită, deci Math.Round(2.5) este 2, nu 3. Motivul pentru care s-a ales acest standard: într-o serie lungă de rotunjiri (de exemplu în contabilitate), rotunjirea mereu în sus a jumătăților introduce o eroare sistematică, iar rotunjirea spre par o compensează.

Dacă vrei rotunjirea „de la școală”, o ceri explicit:

C#
Math.Round(2.5, MidpointRounding.AwayFromZero);   // 3
Math.Round(19.125m, 2, MidpointRounding.AwayFromZero); // 19.13
Math.Floor(-3.5);    // -4
Math.Ceiling(3.1);   // 4
Math.Truncate(-3.9); // -3

Încă o capcană: Math.Round(2.675, 2) pe double poate da 2.67, pentru că 2,675 nu se reprezintă exact în binar și este de fapt puțin sub jumătate. Pentru sume de bani faci rotunjirea pe decimal, unde valoarea este exactă.

Ce urmărește intervievatorul: Testează atenția la detalii care produc diferențe de un ban în facturi. Răspunsul greșit tipic este că Math.Round(2.5) dă 3.

Eroarea, în practică:CS0266: Cannot implicitly convert 'double' to 'int'

5 Junior

Care este diferența dintre int.Parse, int.TryParse și Convert.ToInt32 când transformi un text în număr? Ce poate merge prost cu double.Parse("1.5")?

Răspuns scurt: Parse aruncă excepție la text invalid, TryParse întoarce false fără excepție, iar Convert.ToInt32(null) întoarce 0. double.Parse depinde de cultura curentă: în română „1.5” poate deveni 15.

Cele trei variante diferă prin felul în care tratează datele invalide:

C#
int a = int.Parse("42");            // 42
int b = int.Parse("abc");           // FormatException
int c = int.Parse(null!);           // ArgumentNullException
int d = Convert.ToInt32((string?)null); // 0
bool ok = int.TryParse("abc", out int e); // ok = false, e = 0

TryParse este alegerea corectă pentru date venite de la utilizator sau din fișiere, unde textul invalid este o situație normală, nu o excepție. Evită costul unei excepții și face codul mai clar:

C#
if (!int.TryParse(input, out int varsta) || varsta < 0)
{
    Console.WriteLine("Vârstă invalidă");
    return;
}

Problema mai subtilă este cultura. double.Parse, decimal.Parse și ToString() folosesc implicit CultureInfo.CurrentCulture. În cultura ro-RO, separatorul zecimal este virgula, iar punctul este separator de mii. Așa că double.Parse("1.5") pe un server configurat în română întoarce 15, fără nicio eroare. Același cod rulat pe un calculator în engleză dă 1,5.

Pentru date cu format fix (fișiere CSV, JSON, configurări), specifici cultura invariantă:

C#
double x = double.Parse("1.5", CultureInfo.InvariantCulture); // 1.5
string s = x.ToString(CultureInfo.InvariantCulture);           // "1.5"

Pentru texte introduse de oameni folosești cultura lor. Regula: formatul pentru mașini este invariant, formatul pentru oameni este cel local.

Ce urmărește intervievatorul: Verifică dacă tratezi corect datele invalide și dacă știi de cultură. Bug-urile de tip „merge la mine, nu merge pe server” vin des din Parse fără cultură.

Eroarea, în practică:CS0029: Cannot implicitly convert 'string' to 'int'CS0030: Cannot convert type 'string' to 'int'

6 Junior

Ce afișează codul următor?

C#
int i = 5;
int a = i++;
int b = ++i;
Console.WriteLine($"{a} {b} {i}");

int j = 5;
j = j++;
Console.WriteLine(j);

Răspuns scurt: Afișează „5 7 7” și apoi 5. Postincrementarea întoarce valoarea veche și apoi crește variabila, preincrementarea crește întâi și întoarce valoarea nouă.

i++ (postincrementare) evaluează la valoarea curentă a lui i, iar ca efect secundar îl crește. ++i (preincrementare) îl crește întâi și evaluează la noua valoare.

Pas cu pas:

  • int a = i++; atribuie lui a valoarea 5, apoi i devine 6
  • int b = ++i; crește i la 7, apoi atribuie lui b valoarea 7
  • la afișare: a = 5, b = 7, i = 7

Al doilea exemplu este o capcană clasică. În j = j++; se întâmplă, în ordine: se citește valoarea veche a lui j (5), se crește j la 6, apoi se execută atribuirea, care scrie în j valoarea veche citită, adică 5. Incrementarea se pierde. Spre deosebire de C și C++, unde o astfel de expresie are comportament nedefinit, în C# ordinea de evaluare este strict definită (de la stânga la dreapta), deci rezultatul este mereu 5.

Lecția practică nu este să memorezi astfel de expresii, ci să le eviți. Într-un for, i++ și ++i sunt echivalente, pentru că valoarea expresiei nu se folosește. Problema apare doar când combini incrementarea cu alte operații în aceeași expresie:

C#
int k = 1;
int r = k++ + ++k; // 1 + 3 = 4, k = 3

Un cod ca acesta trece de compilator, dar nu trece de un code review. Scrie incrementarea pe o linie separată.

Ce urmărește intervievatorul: Verifică înțelegerea evaluării expresiilor cu efecte secundare. Candidații buni explică și de ce nu ar scrie așa ceva în cod real.

7 Junior

Cum întorci mai multe valori dintr-o metodă în C#? Arată varianta cu tupluri și deconstrucție.

Răspuns scurt: Ai trei variante principale: parametri out, un tuplu cu nume ((int Min, int Max)) sau un tip dedicat, de obicei un record. Tuplurile se pot deconstrui direct în variabile.

Tuplurile valoare (ValueTuple, din C# 7) sunt cea mai scurtă variantă pentru o metodă privată sau locală:

C#
static (int Min, int Max, double Media) Statistici(int[] numere)
{
    int min = int.MaxValue, max = int.MinValue;
    long suma = 0;
    foreach (int n in numere)
    {
        if (n < min) min = n;
        if (n > max) max = n;
        suma += n;
    }
    return (min, max, (double)suma / numere.Length);
}

var s = Statistici(new[] { 4, 8, 15 });
Console.WriteLine(s.Max);              // 15

var (mic, mare, _) = Statistici(new[] { 4, 8, 15 }); // deconstrucție, ignori media

Numele elementelor (Min, Max) sunt doar pentru compilator; la rulare câmpurile se numesc Item1, Item2. Tuplurile sunt struct-uri, au egalitate pe valori ((1, 2) == (1, 2) este true) și sunt utile și pentru schimbări rapide: (a, b) = (b, a);.

Alternativele:

  • out: potrivit pentru tiparul TryXxx (bool TryParse(string s, out int valoare)), unde valoarea de retur e succesul
  • record: când rezultatul are un sens în domeniu, este folosit în mai multe locuri sau traversează granița unui API public

Regula practică: tuplu pentru rezultate interne și de scurtă durată, record pentru tot ce face parte din modelul aplicației. Un tuplu cu cinci elemente într-o semnătură publică devine greu de citit și de modificat.

Poți adăuga deconstrucție și propriilor clase, cu o metodă public void Deconstruct(out string nume, out int varsta).

Ce urmărește intervievatorul: Verifică dacă cunoști C# modern și dacă știi când un tuplu devine prea mult. Răspunsurile slabe se opresc la out sau la crearea unei clase pentru orice.

Eroarea, în practică:CS8132: Cannot deconstruct a tuple

8 Junior

Ce afișează codul următor? Care e diferența dintre && și &?

C#
static bool Verifica(string nume, bool rezultat)
{
    Console.Write(nume + " ");
    return rezultat;
}

if (Verifica("A", false) && Verifica("B", true)) { }
Console.WriteLine();
if (Verifica("A", false) & Verifica("B", true)) { }

Răspuns scurt: Prima linie afișează doar „A”, a doua „A B”. && și || sunt operatori cu scurtcircuitare: nu evaluează operandul din dreapta dacă rezultatul e deja cunoscut. & și | îi evaluează mereu pe amândoi.

La &&, dacă operandul din stânga este false, rezultatul întregii expresii este sigur false, deci operandul din dreapta nu se mai evaluează. Analog, la ||, dacă stânga e true, dreapta se sare. Aceasta este evaluarea cu scurtcircuitare și pe ea se bazează un tipar foarte des întâlnit:

C#
if (text != null && text.Length > 0) { ... }
if (lista.Count == 0 || lista[0] == 0) { ... }

Cu & în loc de &&, primul exemplu ar arunca NullReferenceException când text este null, pentru că text.Length s-ar evalua oricum.

Pe tipul bool, & și | sunt operatori logici fără scurtcircuitare: evaluează mereu ambele părți. Rar ai nevoie de asta intenționat, de exemplu când ambele apeluri au efecte secundare care trebuie să se întâmple. Chiar și atunci, codul e mai clar dacă scrii apelurile separat.

Pe tipurile întregi, aceiași operatori sunt operatori pe biți:

C#
int flags = 0b0101;
Console.WriteLine(flags & 0b0100);  // 4: bitul e setat
Console.WriteLine(flags | 0b0010);  // 7
Console.WriteLine(flags ^ 0b0001);  // 4: XOR inversează bitul

^ pe bool este XOR logic (adevărat când exact unul dintre operanzi e adevărat), iar ! este negația. La interviu merită spus că ordinea condițiilor contează și din motive de performanță: pui verificarea ieftină înaintea celei scumpe.

Ce urmărește intervievatorul: Verifică dacă știi de ce x != null && x.Prop funcționează. Greșeala tipică este folosirea lui & din obișnuință din alte limbaje.

9 Junior

Ce afișează codul următor cu int??

C#
int? a = null;
int? b = a + 5;
Console.WriteLine(b == null);
Console.WriteLine(a > 0);
Console.WriteLine(a <= 0);
Console.WriteLine(a.GetValueOrDefault());

Răspuns scurt: Afișează True, False, False și 0. Operatorii aritmetici pe int? întorc null dacă un operand e null, iar comparațiile <, >, <=, >= cu null sunt mereu false.

int? este prescurtarea pentru Nullable<int>, un struct care conține o valoare și un flag HasValue. Pentru el, compilatorul „ridică” operatorii obișnuiți ai lui int (în engleză lifted operators):

  • operatorii aritmetici (+, -, * etc.) întorc null dacă oricare operand este null; de aceea a + 5 este null
  • operatorii de comparație <, >, <=, >= întorc false dacă oricare operand este null
  • == și != tratează null ca valoare: null == null este true

Rezultatul surprinzător este că atât a > 0, cât și a <= 0 sunt false. Logica „dacă nu e mai mare, atunci e mai mic sau egal” nu mai funcționează cu valori lipsă. Un bug real: if (reducere > 0) aplica(); else nuAplica(); pune în ramura else și cazul în care reducerea nu a fost completată deloc, poate fără intenție.

Moduri sigure de a lucra cu valoarea:

C#
int? cantitate = CitesteCantitate();
if (cantitate.HasValue) Console.WriteLine(cantitate.Value);
if (cantitate is int c) Console.WriteLine(c);      // pattern matching
int x = cantitate ?? 1;                            // valoare implicită
int y = cantitate.GetValueOrDefault();             // 0 dacă e null
int z = cantitate.Value;  // InvalidOperationException dacă e null

int? este util când „lipsa valorii” are un sens distinct de 0: o notă încă nedată, o dată de expirare opțională, o coloană NULL din baza de date. Nu-l folosi pentru a evita să decizi ce înseamnă valoarea implicită.

Ce urmărește intervievatorul: Verifică dacă știi cum se comportă comparațiile cu null. Aproape toți candidații presupun că una dintre cele două comparații este adevărată.

Eroarea, în practică:Nullable object must have a valueCS0037: Cannot convert null to 'int'

10 Mid

Ce afișează codul următor? Ce este [Flags] și cum îl folosești?

C#
enum Status { Activ = 1, Suspendat = 2 }

Status s = default;
Status t = (Status)42;
Console.WriteLine(s);
Console.WriteLine(t);
Console.WriteLine(Enum.IsDefined(t));

Răspuns scurt: Afișează 0, 42 și False. Un enum este doar un număr cu nume, deci poate primi orice valoare a tipului de bază, chiar nedefinită. [Flags] marchează un enum ale cărui valori sunt biți combinabili.

Un enum are un tip de bază întreg (implicit int), iar variabila stochează doar acel număr. Compilatorul și runtime-ul nu verifică dacă valoarea corespunde unui membru definit:

  • default pentru orice enum este 0, chiar dacă nu ai definit un membru cu valoarea 0, deci s se afișează ca „0”
  • cast-ul (Status)42 reușește fără excepție, iar ToString() afișează numărul
  • Enum.IsDefined (varianta generică există din .NET 5) îți spune dacă valoarea are nume

Consecințe practice: definește mereu un membru cu valoarea 0 care are sens (Necunoscut sau Niciunul) și validează valorile care vin din exterior (JSON, bază de date, parametri de API).

[Flags] se folosește când valorile se pot combina. Le dai puteri ale lui 2, ca fiecare să ocupe un bit:

C#
[Flags]
enum Permisiuni { Niciuna = 0, Citire = 1, Scriere = 2, Stergere = 4 }

var p = Permisiuni.Citire | Permisiuni.Scriere;
Console.WriteLine(p);                              // Citire, Scriere
Console.WriteLine(p.HasFlag(Permisiuni.Scriere));  // True
Console.WriteLine((p & Permisiuni.Stergere) != 0); // False
p &= ~Permisiuni.Scriere;                          // elimină un flag

Atributul schimbă afișarea (ToString listează combinația) și comunică intenția. Fără valori puteri ale lui 2, combinațiile se suprapun și rezultatul e greșit. Într-un switch pe enum adaugă mereu un caz implicit care tratează valorile neașteptate, tocmai pentru că ele pot exista.

Ce urmărește intervievatorul: Verifică dacă știi că un enum nu e un tip sigur. Greșeala tipică este presupunerea că o variabilă enum conține mereu un membru valid.

11 Mid

De ce primul Console.WriteLine compilează și afișează 0, iar ultimul nu compilează?

C#
class Contor
{
    public int Valoare;
    public string? Nume;
}

var c = new Contor();
Console.WriteLine(c.Valoare);
Console.WriteLine(c.Nume == null);

int x;
Console.WriteLine(x);

Răspuns scurt: Câmpurile unui obiect sunt inițializate automat de runtime cu valoarea implicită (0, null, false). Variabilele locale nu primesc valoare automat, iar compilatorul cere ca ele să fie atribuite înainte de citire (eroarea CS0165).

Când se creează un obiect, memoria alocată pe heap este pusă pe zero înainte să ruleze constructorul. De aceea orice câmp are o valoare bine definită: 0 pentru numere, false pentru bool, null pentru referințe, '\0' pentru char, iar struct-urile au toate câmpurile pe zero. Același lucru se întâmplă cu elementele unui tablou nou: new int[5] conține cinci zerouri.

Variabilele locale sunt tratate diferit. C# aplică regula de definite assignment: compilatorul analizează toate drumurile prin cod și refuză să compileze dacă există unul pe care variabila este citită fără să fi fost atribuită. Motivul este de design, nu tehnic: o variabilă locală necitită este aproape mereu un bug (ai uitat o ramură else), iar compilatorul îl prinde înainte de rulare.

C#
int nota;
if (punctaj > 50) nota = 10;
Console.WriteLine(nota); // CS0165: drumul cu punctaj <= 50 nu atribuie

int nota2 = punctaj > 50 ? 10 : 4; // corect

Poți cere explicit valoarea implicită a oricărui tip cu default:

C#
int a = default;          // 0
string? s = default;      // null
T valoare = default!;     // într-o metodă generică

Cu nullable reference types activat (implicit în proiectele .NET noi), un câmp public string Nume; neinițializat în constructor produce avertismentul CS8618, pentru că valoarea lui reală va fi null, deși tipul spune că nu poate fi. De aceea, în exemplu, câmpul este declarat string?.

Ce urmărește intervievatorul: Verifică înțelegerea diferenței dintre memoria obiectelor și variabilele locale. Candidații slabi nu știu de ce compilatorul refuză codul.

Eroarea, în practică:CS0165: Use of unassigned local variable

12 Mid

Ce afișează codul următor și de ce?

C#
double x = 0.0 / 0.0;
Console.WriteLine(x == x);
Console.WriteLine(x.Equals(x));
Console.WriteLine(double.IsNaN(x));
Console.WriteLine(1.0 / 0);

Răspuns scurt: Afișează False, True, True și simbolul infinitului. NaN nu este egal cu nimic, nici cu el însuși, prin operatorul ==, dar Equals îl consideră egal cu sine, ca să funcționeze în colecții.

Împărțirea în virgulă mobilă nu aruncă excepție. 0.0 / 0.0 produce NaN (Not a Number), iar 1.0 / 0 produce infinit pozitiv (afișat ca „∞” sau „Infinity”, în funcție de cultură). Doar împărțirea între întregi la zero aruncă DivideByZeroException la rulare, iar 1 / 0 scris cu constante nici nu compilează (CS0020).

Standardul IEEE 754 spune că orice comparație cu NaN este falsă, inclusiv NaN == NaN. Ideea este că NaN reprezintă un rezultat nedefinit, iar două rezultate nedefinite nu sunt neapărat „același lucru”. De aceea singura verificare corectă este double.IsNaN(x); un test if (x == double.NaN) nu va fi niciodată adevărat.

Equals întoarce totuși true. Motivul: colecțiile (Dictionary, HashSet, List.Contains, sortarea) se bazează pe contractul că Equals este reflexiv, adică x.Equals(x) este mereu adevărat. Fără asta, nu ai putea găsi niciodată o cheie NaN într-un dicționar. Este unul dintre puținele locuri unde == și Equals dau intenționat rezultate diferite pe același tip.

Consecințe practice:

  • un NaN se propagă: orice calcul cu el dă NaN, deci o singură valoare lipsă poate strica o medie întreagă
  • Math.Max(1, double.NaN) întoarce NaN
  • validează intrările (de exemplu double.IsFinite(x)) înainte să le folosești în calcule sau să le salvezi
C#
double[] valori = { 1, double.NaN, 3 };
Console.WriteLine(valori.Average());                          // NaN
Console.WriteLine(valori.Where(double.IsFinite).Average());  // 2

Ce urmărește intervievatorul: Testează cunoașterea semanticii virgulei mobile și a contractului lui Equals. Puțini candidați știu de ce Equals diferă de == aici.

Eroarea, în practică:DivideByZeroException: Attempted to divide by zero

String-uri și text

13 Junior

Ce afișează fiecare linie?

C#
Console.WriteLine('a' + 'b');
Console.WriteLine("a" + 'b');
Console.WriteLine('a' + 1);
Console.WriteLine((char)('a' + 1));
Console.WriteLine(1 + 2 + "3" + 4 + 5);

Răspuns scurt: Afișează 195, ab, 98, b și 3345. Un char este un număr (codul UTF-16), deci char + char este o adunare de întregi; concatenarea apare abia când un operand este string, iar evaluarea merge de la stânga la dreapta.

char în C# este un tip numeric pe 16 biți care stochează o unitate de cod UTF-16. Când aduni două char-uri, ambele sunt promovate la int: 'a' are codul 97, 'b' are 98, deci rezultatul este 195. Nu există operator + care să lipească două caractere într-un text.

Dacă un operand este string, + devine concatenare, iar celălalt operand este convertit cu ToString(). De aceea "a" + 'b' dă "ab".

'a' + 1 este tot o adunare de întregi: 98. Ca să obții caracterul următor, faci cast înapoi: (char)('a' + 1) este 'b'. Tiparul acesta apare la cifrul lui Cezar sau la conversia unei cifre: (char)('0' + 7) este '7', iar invers '7' - '0' este 7.

Ultima linie arată ordinea de evaluare, de la stânga la dreapta:

  • 1 + 2 = 3 (adunare de întregi)
  • 3 + "3" = "33" (de aici înainte totul e text)
  • "33" + 4 = "334"
  • "334" + 5 = "3345"

Ca să eviți confuzia, folosește interpolarea, unde intenția este explicită:

C#
char c1 = 'a', c2 = 'b';
string s = $"{c1}{c2}";                 // "ab"
string t = string.Concat(c1, c2);       // "ab"
int suma = 1 + 2;
Console.WriteLine($"{suma}3{4 + 5}");  // "339"

Reține și că un char nu poate reprezenta orice simbol: emoji-urile și unele caractere rare ocupă două unități UTF-16 (o pereche surogat), deci "text".Length numără unități, nu litere vizibile.

Ce urmărește intervievatorul: Verifică înțelegerea tipului char și a ordinii de evaluare. Răspunsul greșit tipic este „ab” pe prima linie.

Eroarea, în practică:CS1012: Too many characters in character literalCS1011: Empty character literal

14 Junior

Cum compari corect două string-uri fără să ții cont de majuscule? De ce a.ToLower() == b.ToLower() nu este cea mai bună variantă?

Răspuns scurt: Folosești string.Equals(a, b, StringComparison.OrdinalIgnoreCase). Varianta cu ToLower() creează două string-uri noi, depinde de cultura curentă și aruncă excepție dacă a este null.

Operatorul == pe string compară conținutul, caracter cu caracter, ținând cont de majuscule. Pentru comparații fără majuscule, API-ul corect este cel cu StringComparison:

C#
string? a = "Admin", b = "ADMIN";
bool egale = string.Equals(a, b, StringComparison.OrdinalIgnoreCase); // True
bool incepe = "Raport.PDF".EndsWith(".pdf", StringComparison.OrdinalIgnoreCase);
var dict = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

De ce nu a.ToLower() == b.ToLower():

  • alocă două string-uri noi la fiecare comparație, ceea ce contează într-o buclă
  • dacă a este null, aruncă NullReferenceException; metoda statică string.Equals tratează null fără probleme
  • ToLower() folosește cultura curentă; exemplul clasic este turca, unde "I".ToLower() nu este "i", ci un „ı” fără punct, deci "FILE".ToLower() == "file" dă false pe un sistem configurat în turcă

Alegerea tipului de comparație:

  • Ordinal / OrdinalIgnoreCase: compară codurile caracterelor; rapid și previzibil. Îl folosești pentru identificatori, chei, extensii de fișiere, nume de antete HTTP, tot ce e „pentru mașini”
  • CurrentCulture / CurrentCultureIgnoreCase: respectă regulile limbii; îl folosești când sortezi sau compari texte afișate oamenilor, de exemplu o listă de nume cu diacritice
  • InvariantCulture: rar necesar, pentru reguli lingvistice stabile indiferent de sistem

O regulă bună: când o metodă de string are o variantă cu StringComparison, folosește-o și alege explicit. Analizoarele .NET (de exemplu CA1309 și CA1862) semnalează locurile unde lipsește.

Ce urmărește intervievatorul: Verifică dacă știi de comparațiile ordinale și culturale. Un candidat bun pomenește null, alocările și exemplul cu turca.

15 Junior

Cum formatezi numere și texte cu interpolare în C#? Ce sunt string-urile verbatim și raw string literals?

Răspuns scurt: Interpolarea $"..." acceptă după expresie un format ({pret:N2}) și o lățime de aliniere ({nume,-10}). @"..." este un string verbatim, fără secvențe escape, iar """...""" (C# 11) este un raw string literal, util pentru JSON sau SQL.

Într-o expresie interpolată, forma completă este {expresie,aliniere:format}:

C#
decimal pret = 1234.5m;
string nume = "Ana";
Console.WriteLine($"{pret:N2}");      // 1.234,50 în cultura ro-RO
Console.WriteLine($"{pret:C}");       // format monetar al culturii curente
Console.WriteLine($"{0.256:P1}");     // procent cu o zecimală
Console.WriteLine($"[{nume,6}]");     // [   Ana], aliniat la dreapta
Console.WriteLine($"[{nume,-6}]");    // [Ana   ], aliniat la stânga
Console.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm}");
Console.WriteLine($"{42:D5}");        // 00042
Console.WriteLine($"{{acolade}}");    // {acolade}

Formatul depinde de cultura curentă, la fel ca ToString(). Pentru ieșiri destinate altor programe folosești string.Create(CultureInfo.InvariantCulture, $"...") sau FormattableString.Invariant($"...").

Un string verbatim începe cu @: backslash-ul nu mai este caracter de escape, iar textul poate continua pe mai multe rânduri. Este forma obișnuită pentru căi Windows și expresii regulate:

C#
string cale = @"C:\temp\rapoarte\iunie.txt";
string regex = @"^\d{3}-\d{4}$";

Ghilimelele din interiorul unui verbatim se dublează (""), ceea ce devine incomod pentru JSON. Pentru asta, C# 11 a adus raw string literals, delimitate de cel puțin trei ghilimele. Conținutul este luat exact cum e scris, iar indentarea comună este eliminată după poziția ghilimelelor de închidere:

C#
string json = """
    { "nume": "Ana", "varsta": 30 }
    """;

Combinat cu interpolarea, numărul de $ arată câte acolade marchează o expresie: în $$"""{ "nume": "{{nume}}" }""" acoladele simple sunt text, iar {{nume}} este expresia.

Ce urmărește intervievatorul: Verifică familiaritatea cu formatarea de zi cu zi și cu C# modern. Candidații juniori cunosc rar alinierea și raw strings.

Eroarea, în practică:CS1009: Unrecognized escape sequenceCS8361: conditional expression in interpolation

16 Junior

Ce afișează codul următor? Ce fac opțiunile din Split?

C#
string linie = "  ana, ,mihai,,  ion ";
var nume = linie.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Console.WriteLine(nume.Length);
Console.WriteLine(string.Join("|", nume));

Răspuns scurt: Afișează 3 și „ana|mihai|ion”. TrimEntries (din .NET 5) elimină spațiile de la capetele fiecărei bucăți, iar RemoveEmptyEntries elimină bucățile goale, inclusiv cele care au rămas goale după trim.

Fără opțiuni, linie.Split(',') întoarce cinci elemente: " ana", " ", "mihai", "" și " ion ". Adică exact ce era între virgule, cu spații și bucăți goale. Pentru date introduse de oameni sau citite din fișiere, aproape mereu vrei să le cureți.

Opțiunile se combină cu |, pentru că StringSplitOptions este un enum [Flags]:

  • TrimEntries aplică Trim() pe fiecare element
  • RemoveEmptyEntries elimină elementele goale; combinat cu TrimEntries, elimină și elementele care conțineau doar spații

Rezultatul este ["ana", "mihai", "ion"], iar string.Join("|", nume) le lipește înapoi cu separatorul dat.

Alte variante utile:

C#
"a;b,c".Split(new[] { ';', ',' });           // mai mulți separatori
"cheie=valoare=x".Split('=', 2);             // maximum 2 bucăți: "cheie", "valoare=x"
"rând1\r\nrând2".Split(new[] { "\r\n", "\n" }, StringSplitOptions.None);
string.Join(", ", new List<int> { 1, 2, 3 }); // "1, 2, 3"

Limitarea numărului de bucăți este importantă când valoarea poate conține separatorul, ca în al doilea exemplu.

Atenție însă: Split nu este un parser CSV. Un câmp ca "Popescu, Ion" între ghilimele va fi rupt greșit în două. Pentru fișiere CSV reale folosești o bibliotecă dedicată (de exemplu CsvHelper) sau un parser scris atent, care tratează ghilimelele.

Pentru texte foarte mari sau în bucle fierbinți, Split alocă un tablou și câte un string pentru fiecare bucată; în .NET 8, MemoryExtensions.Split pe ReadOnlySpan<char> permite împărțirea fără aceste alocări.

Ce urmărește intervievatorul: Verifică dacă știi să cureți date de intrare și dacă recunoști limitele lui Split. Mulți juniori scriu bucle manuale de trim și filtrare.

17 Junior

Scrie o funcție care verifică dacă un text este palindrom, ignorând spațiile, semnele de punctuație și majusculele. De exemplu „Ele fac cafele” este palindrom.

Răspuns scurt: Folosești doi indici, unul de la început și unul de la sfârșit, sari peste caracterele care nu sunt litere sau cifre și compari restul fără majuscule. Soluția este O(n) în timp și nu alocă memorie suplimentară.

Soluția cu doi indici evită crearea de string-uri intermediare:

C#
static bool EstePalindrom(string text)
{
    ArgumentNullException.ThrowIfNull(text);
    int st = 0, dr = text.Length - 1;
    while (st < dr)
    {
        if (!char.IsLetterOrDigit(text[st])) { st++; continue; }
        if (!char.IsLetterOrDigit(text[dr])) { dr--; continue; }
        if (char.ToLowerInvariant(text[st]) != char.ToLowerInvariant(text[dr]))
            return false;
        st++;
        dr--;
    }
    return true;
}

Console.WriteLine(EstePalindrom("Ele fac cafele"));  // True
Console.WriteLine(EstePalindrom("Ana are mere"));    // False
Console.WriteLine(EstePalindrom(""));                // True

Cum explici soluția la interviu:

  • st și dr pornesc de la capete și se apropie; ne oprim când se întâlnesc
  • caracterele irelevante sunt sărite, nu eliminate, deci nu construim un text nou
  • complexitatea este O(n) timp și O(1) memorie suplimentară

Varianta mai scurtă, acceptabilă dacă intervievatorul cere claritate, nu performanță:

C#
static bool EstePalindromSimplu(string text)
{
    var curat = text.Where(char.IsLetterOrDigit).Select(char.ToLowerInvariant).ToArray();
    return curat.SequenceEqual(curat.Reverse());
}

Aceasta alocă un tablou și un iterator, dar este ușor de citit. E bine să prezinți ambele și să explici compromisul.

Merită menționate și cazurile limită: text gol (palindrom prin convenție), text doar cu spații, null (aici aruncăm excepție explicit). Diacriticele funcționează corect, pentru că char.IsLetterOrDigit recunoaște „ă” sau „ș”; dacă vrei ca „ă” să fie egal cu „a”, ai nevoie de normalizare Unicode, o discuție separată.

Ce urmărește intervievatorul: Este o problemă de cod live clasică. Intervievatorul urmărește cazurile limită și dacă poți discuta complexitatea, nu doar o soluție care merge.

18 Junior

Care este diferența dintre un string null, unul gol și unul care conține doar spații? Cum le verifici?

Răspuns scurt: null înseamnă că nu există niciun obiect, "" este un string valid de lungime 0, iar " " are lungime, dar doar spații. string.IsNullOrEmpty acoperă primele două cazuri, string.IsNullOrWhiteSpace pe toate trei.

Sunt trei stări distincte:

C#
string? a = null;     // nu referă niciun obiect
string b = "";        // obiect string cu Length = 0 (la fel ca string.Empty)
string c = "   ";     // Length = 3, doar spații

Console.WriteLine(a?.Length);                  // nimic (null)
Console.WriteLine(b.Length);                   // 0
Console.WriteLine(string.IsNullOrEmpty(c));      // False
Console.WriteLine(string.IsNullOrWhiteSpace(c)); // True
Console.WriteLine(a.Length);                   // NullReferenceException

Pentru validarea câmpurilor introduse de utilizator (nume, adresă, email), aproape mereu vrei IsNullOrWhiteSpace: un nume format doar din spații nu este un nume. IsNullOrEmpty este potrivit când spațiile sunt conținut legitim, de exemplu un separator configurabil.

"" și string.Empty sunt echivalente; literalul gol este oricum o singură instanță partajată, deci nu există diferență de performanță. Alegerea ține de stilul echipei.

Cu nullable reference types (activat implicit în proiectele .NET noi), tipul spune dacă null este permis: string? poate fi null, string nu ar trebui să fie. Compilatorul înțelege metodele de verificare:

C#
static string Salut(string? nume)
{
    if (string.IsNullOrWhiteSpace(nume))
        return "Salut, vizitatorule!";
    return $"Salut, {nume.Trim()}!"; // fără avertisment: compilatorul știe că nu e null
}

O decizie de design utilă: la granița aplicației (formular, API), transformi intrările goale sau doar cu spații într-o singură reprezentare (de obicei null sau eroare de validare), ca restul codului să nu mai trebuiască să trateze trei variante.

Ce urmărește intervievatorul: Verifică validarea corectă a intrărilor. Greșeala tipică este folosirea lui IsNullOrEmpty pentru câmpuri obligatorii, care acceptă astfel doar spații.

Eroarea, în practică:NullReferenceException: Object reference not set

19 Mid

Scrie o funcție care verifică dacă două cuvinte sunt anagrame. Ce complexitate are soluția ta?

Răspuns scurt: Numeri frecvența fiecărui caracter din primul cuvânt și o scazi pentru al doilea; dacă vreun contor ajunge negativ, nu sunt anagrame. Soluția este O(n) timp, față de O(n log n) pentru varianta cu sortare.

Două cuvinte sunt anagrame dacă au exact aceleași litere, în aceleași cantități. Prima verificare ieftină este lungimea:

C#
static bool SuntAnagrame(string a, string b)
{
    if (a.Length != b.Length) return false;

    var frecv = new Dictionary<char, int>();
    foreach (char ch in a)
        frecv[ch] = frecv.GetValueOrDefault(ch) + 1;

    foreach (char ch in b)
    {
        if (!frecv.TryGetValue(ch, out int n) || n == 0)
            return false;
        frecv[ch] = n - 1;
    }
    return true;
}

Console.WriteLine(SuntAnagrame("listen", "silent")); // True
Console.WriteLine(SuntAnagrame("ana", "nan"));       // False

Complexitatea este O(n) timp și O(k) memorie, unde k este numărul de caractere distincte. Pentru că lungimile sunt egale, dacă nu am găsit niciun contor epuizat, toate contoarele ajung la zero, deci nu mai trebuie verificat dicționarul la final.

Dacă știi că intrarea conține doar litere mici a–z, un tablou int[26] indexat cu ch - 'a' este mai rapid decât dicționarul, pentru că evită calculul de hash.

Alternativa scurtă este sortarea:

C#
static bool SuntAnagrameSort(string a, string b) =>
    a.Length == b.Length && a.Order().SequenceEqual(b.Order());

Order() există din .NET 7. Soluția este O(n log n) și alocă memorie, dar e foarte lizibilă.

La interviu e bine să întrebi ce înseamnă „anagramă” în contextul dat: contează majusculele? Spațiile („Dormitor” și „Dirt room” sunt anagrame dacă le ignori)? Diacriticele? Normalizarea se face înainte de numărare, de exemplu cu char.ToLowerInvariant și filtrarea cu char.IsLetter.

Ce urmărește intervievatorul: Verifică dacă alegi structura de date potrivită și dacă poți compara două soluții. Candidații buni întreabă de cerințe înainte să scrie cod.

20 Senior

Ce afișează codul următor? Ce este string interning?

C#
string a = "salut";
string b = "sal" + "ut";
string c = new string("salut".ToCharArray());
object o1 = a, o2 = c;

Console.WriteLine(ReferenceEquals(a, b));
Console.WriteLine(ReferenceEquals(a, c));
Console.WriteLine(a == c);
Console.WriteLine(o1 == o2);
Console.WriteLine(ReferenceEquals(a, string.Intern(c)));

Răspuns scurt: Afișează True, False, True, False, True. Literalii sunt internați (o singură instanță per valoare), concatenarea de constante se face la compilare, iar == pe variabile de tip object compară referințe, nu conținut.

String interning înseamnă că runtime-ul păstrează un tabel cu o singură instanță pentru fiecare literal string din cod. Toate aparițiile lui "salut" din assembly referă același obiect.

Linie cu linie:

  • "sal" + "ut" este o expresie constantă, pe care compilatorul o calculează la compilare și o transformă în literalul "salut"; deci a și b referă aceeași instanță internată: True
  • new string(...) creează mereu un obiect nou pe heap: ReferenceEquals este False
  • a == c folosește operatorul == definit pe string, care compară conținutul: True
  • o1 == o2 este capcana: operatorii în C# se aleg la compilare după tipul declarat; pentru object, == înseamnă egalitate de referință: False; compilatorul dă avertismentul CS0252/CS0253 când compari object cu string
  • string.Intern(c) caută valoarea în tabel și întoarce instanța existentă: True

Lecțiile practice:

  • nu te baza pe identitatea referințelor la string-uri; compară mereu cu == sau string.Equals pe variabile de tip string
  • bug-ul cu object apare real în cod generic sau la colecții de tip object (de exemplu Dictionary<string, object> unde compari valorile); folosește Equals, care este virtual
  • string.Intern manual reduce memoria când ai multe string-uri repetate citite la rulare (de exemplu coduri de țară dintr-un fișier mare), dar instanțele internate trăiesc până la oprirea procesului; o alternativă controlabilă este un HashSet<string> folosit ca pool sau StringPool din pachetul CommunityToolkit.HighPerformance

Ce urmărește intervievatorul: Verifică înțelegerea diferenței dintre egalitatea de referință și cea de valoare și a rezolvării statice a operatorilor. Linia cu object prinde și candidați experimentați.

Clase, moștenire și polimorfism

Exersează capitolul cu exerciții reale: Curs C# →
21 Junior

Care este diferența dintre { get; set; }, { get; private set; }, { get; } și { get; init; } la o proprietate?

Răspuns scurt: get; set; se poate modifica de oriunde, private set doar din interiorul clasei, get; doar din constructor, iar init (C# 9) și din inițializatorul de obiect, apoi devine doar de citire.

Toate patru sunt proprietăți automate: compilatorul generează câmpul privat din spate. Diferă prin cine are voie să scrie valoarea și când.

C#
public class Comanda
{
    public string Observatii { get; set; } = "";     // oricine, oricând
    public string Status { get; private set; } = "Nouă"; // doar metodele clasei
    public int Id { get; }                         // doar constructorul
    public string Client { get; init; } = "";      // constructor sau inițializator
    public decimal Total => _linii.Sum(l => l.Pret); // calculată, fără câmp

    private readonly List<(string Produs, decimal Pret)> _linii = new();

    public Comanda(int id) => Id = id;

    public void Trimite() => Status = "Trimisă";
}

var c = new Comanda(7) { Client = "Ana" }; // init permis aici
c.Observatii = "la ușă";                    // permis
// c.Status = "Livrată";   // eroare: setter privat
// c.Id = 8;               // eroare: doar citire
// c.Client = "Ion";       // eroare: init doar la creare

Când alegi fiecare:

  • private set când starea se schimbă, dar doar prin operații cu sens în domeniu (Trimite()), nu prin atribuire directă; așa păstrezi regulile într-un singur loc
  • get; sau init; pentru valori care nu se mai schimbă după creare; init este comod pentru obiecte cu multe proprietăți opționale, unde un constructor cu zece parametri ar fi greu de citit
  • proprietate calculată (=>) când valoarea derivă din alte date; așa nu poate deveni inconsistentă

init nu garantează că proprietatea a fost setată; pentru asta există required (C# 11).

Ce urmărește intervievatorul: Verifică dacă folosești proprietățile pentru a proteja starea obiectului. Juniorii pun adesea get; set; peste tot din obișnuință.

Eroarea, în practică:CS0200: Property cannot be assigned to -- read onlyCS0154: property lacks the get accessor

22 Junior

Ce afișează codul următor? Ce înseamnă un membru static?

C#
class Utilizator
{
    public static int Numar;
    public string Nume;
    public Utilizator(string nume) { Nume = nume; Numar++; }
}

var u1 = new Utilizator("Ana");
var u2 = new Utilizator("Ion");
Console.WriteLine(Utilizator.Numar);
Console.WriteLine(u1.Nume);

Răspuns scurt: Afișează 2 și Ana. Un câmp static aparține tipului, nu fiecărui obiect, deci există o singură copie partajată de toate instanțele; Nume este câmp de instanță, câte unul pentru fiecare obiect.

Un membru static este legat de clasă, nu de un obiect anume. Se accesează prin numele tipului (Utilizator.Numar), nu printr-o instanță. Fiecare new Utilizator(...) are propriul Nume, dar toate incrementează același Numar, deci după două obiecte valoarea este 2.

Reguli și detalii:

  • o metodă statică nu are this, deci nu poate accesa direct membri de instanță; poate lucra doar cu ce primește ca parametri și cu alți membri statici
  • un constructor static (static Utilizator() { ... }) rulează o singură dată, automat, înainte de prima utilizare a tipului; nu are parametri și nu îl poți apela tu
  • o clasă static (ca Math) nu poate avea instanțe și conține doar membri statici
  • câmpurile statice trăiesc cât trăiește procesul, deci tot ce referă ele nu este colectat de garbage collector

Când folosești static: metode utilitare fără stare (Math.Max, conversii), constante, metode fabrică (TimeSpan.FromMinutes).

Când îl eviți: stare mutabilă partajată. Contorul din exemplu are două probleme reale. Prima: nu este sigur în medii cu mai multe fire de execuție, pentru că Numar++ înseamnă citire, adunare și scriere, iar două fire pot pierde o incrementare; varianta corectă ar fi Interlocked.Increment(ref Numar). A doua: starea globală face testele dependente unele de altele, pentru că valoarea rămâne de la un test la altul. Într-o aplicație reală, un astfel de contor ar trăi într-un serviciu injectat, nu într-un câmp static.

Ce urmărește intervievatorul: Verifică înțelegerea diferenței dintre tip și instanță. Un candidat bun pomenește și problemele stării statice mutabile.

Eroarea, în practică:CS0120: An object reference is requiredCS0026: 'this' is not valid in a static method

23 Junior

Ce afișează Console.WriteLine(produs) pentru un obiect al unei clase proprii? Cum schimbi asta?

Răspuns scurt: Implicit afișează numele complet al tipului, de exemplu „Magazin.Produs”, pentru că object.ToString() întoarce numele tipului. Suprascrii ToString() ca să întorci o descriere utilă.

Orice tip din .NET moștenește din object, care are metoda virtuală ToString(). Implementarea implicită întoarce numele tipului, cu namespace cu tot. Console.WriteLine(object), interpolarea $"{x}" și concatenarea cu + apelează toate ToString().

C#
namespace Magazin;

public class Produs
{
    public string Nume { get; init; } = "";
    public decimal Pret { get; init; }

    public override string ToString() => $"{Nume} ({Pret:N2} lei)";
}

var p = new Produs { Nume = "Caiet", Pret = 12.5m };
Console.WriteLine(p);          // Caiet (12,50 lei)
Console.WriteLine($"Ai ales: {p}");

Fără override, ai fi văzut Magazin.Produs. Cuvântul override este obligatoriu; dacă îl uiți și scrii doar public string ToString(), compilatorul te avertizează că ascunzi metoda din bază, iar Console.WriteLine(p) va apela tot varianta din object.

Câteva observații:

  • record-urile generează automat un ToString() care listează proprietățile: Produs { Nume = Caiet, Pret = 12.5 }
  • ToString() nu ar trebui să arunce excepții sau să facă operații costisitoare; este apelat de debugger, de loguri și de framework-uri fără să te întrebe
  • nu include date sensibile (parole, numere de card), pentru că ajung ușor în loguri
  • pentru afișare în funcție de cultură sau cu formate multiple, tipul poate implementa IFormattable

În Visual Studio și Rider, atributul [DebuggerDisplay("{Nume} - {Pret}")] controlează afișarea în debugger fără să schimbe ToString(), util când formatul pentru utilizatori diferă de cel pentru depanare.

Ce urmărește intervievatorul: O întrebare simplă despre moștenirea din object și override. Verifică și dacă știi pentru ce se folosește ToString() în practică.

Eroarea, în practică:CS0507: cannot change access modifiers (override)

24 Junior

Care este diferența dintre un cast (T)x, operatorul as și operatorul is? Ce se întâmplă pe fiecare linie?

C#
object o = "text";
string s1 = (string)o;
string? s2 = o as string;
StringBuilder? sb = o as StringBuilder;
var x = (StringBuilder)o;

Răspuns scurt: Cast-ul aruncă InvalidCastException dacă tipul nu se potrivește, as întoarce null, iar is doar testează tipul și poate declara o variabilă. Aici sb este null, iar ultima linie aruncă excepție.

Cele trei operații răspund la întrebări diferite:

  • cast explicit (StringBuilder)o: „sunt sigur că e acest tip”; dacă nu e, primești InvalidCastException
  • o as StringBuilder: „încearcă și dă-mi null dacă nu merge”; funcționează doar cu tipuri referință și tipuri nullable (o as int?), nu cu int
  • o is string: „e de acest tip?”; întoarce bool

În exemplu, s1 și s2 primesc același obiect, sb este null, iar ultima linie aruncă excepție, pentru că obiectul este un string.

În C# modern, combinația cea mai curată este pattern matching cu is, care testează și declară variabila într-un singur pas:

C#
if (o is string text && text.Length > 2)
    Console.WriteLine(text.ToUpper());

if (o is not null) { ... }

Varianta veche, cu as urmat de verificare, era des scrisă greșit:

C#
var t = o as string;
Console.WriteLine(t.Length); // NullReferenceException dacă o nu e string

Folosirea lui as fără test de null transformă o eroare clară de tip într-un NullReferenceException mai târziu, într-un loc greu de legat de cauză. Dacă ești sigur de tip, cast-ul explicit e mai bun: eșuează imediat și cu mesajul corect.

Mai e un detaliu: cast-ul poate apela și conversii definite de utilizator (explicit operator) sau conversii numerice ((int)3.7), pe când as și is verifică doar tipul real al obiectului. Iar dacă te trezești testând des tipul concret, poate e nevoie de o metodă virtuală, adică de polimorfism în loc de if după tip.

Ce urmărește intervievatorul: Verifică dacă alegi operația potrivită și cunoști pattern matching. Greșeala tipică este as fără verificarea rezultatului.

Eroarea, în practică:CS0030: Cannot convert type 'string' to 'int'InvalidCastException: Unable to cast object of type

25 Junior

Ce afișează codul următor? Ce regulă folosește compilatorul ca să aleagă metoda?

C#
static class Afisare
{
    public static void Afiseaza(long x)   => Console.WriteLine("long");
    public static void Afiseaza(double x) => Console.WriteLine("double");
    public static void Afiseaza(object x) => Console.WriteLine("object");
}

Afisare.Afiseaza(5);
Afisare.Afiseaza(5.0f);
Afisare.Afiseaza('5');
Afisare.Afiseaza("5");

Răspuns scurt: Afișează long, double, long și object. La supraîncărcare, compilatorul alege la compilare varianta cu conversia „cea mai bună”: de la int există conversie implicită și spre long, și spre double, dar long este mai specific.

Supraîncărcarea (overloading) înseamnă mai multe metode cu același nume și parametri diferiți. Alegerea se face la compilare, pe baza tipurilor declarate ale argumentelor, prin procesul numit overload resolution.

Linie cu linie:

  • 5 este int; nu există Afiseaza(int), dar există conversii implicite int → long, int → double și int → object (boxing). Dintre long și double, long este „mai bun”, pentru că există conversie implicită de la long la double, dar nu invers. Regula: tipul mai specific câștigă. Rezultat: long
  • 5.0f este float; singura conversie numerică implicită potrivită este spre double: double
  • '5' este char, care se convertește implicit la tipuri numerice întregi; long câștigă din nou: long. Surprinzător pentru mulți, care se așteaptă la object
  • "5" este string; singura variantă compatibilă este object: object

Diferența față de suprascriere (overriding) este esențială:

  • overloading: același nume, semnături diferite, decizie la compilare după tipul declarat
  • overriding: aceeași semnătură într-o clasă derivată, cu virtual/override, decizie la rulare după tipul real al obiectului
C#
object o = 5;
Afisare.Afiseaza(o); // object, chiar dacă valoarea e un int

Aici tipul declarat este object, deci se alege Afiseaza(object), deși la rulare valoarea e număr. Supraîncărcările care diferă doar prin tipuri numerice apropiate sunt o sursă de confuzie; în API-urile proprii e mai sigur să dai nume diferite (AfiseazaText, AfiseazaNumar).

Ce urmărește intervievatorul: Testează înțelegerea faptului că overload resolution este statică. Linia cu char și exemplul cu object separă candidații care știu regula de cei care ghicesc.

Eroarea, în practică:CS0121: The call is ambiguous between methods

26 Junior

Poate o clasă abstractă să aibă constructor? Dacă nu poți crea instanțe din ea, la ce folosește?

Răspuns scurt: Da. Constructorul unei clase abstracte nu se apelează cu new, ci din constructorii claselor derivate, prin base(...), și inițializează partea comună a stării. De obicei îl declari protected.

O clasă abstract nu poate fi instanțiată direct, dar poate avea câmpuri, proprietăți, metode concrete și constructori. Când creezi un obiect dintr-o clasă derivată, constructorul bazei rulează întotdeauna, ca să inițializeze partea din obiect definită în bază.

C#
public abstract class Forma
{
    public string Nume { get; }

    protected Forma(string nume)
    {
        if (string.IsNullOrWhiteSpace(nume))
            throw new ArgumentException("Numele e obligatoriu", nameof(nume));
        Nume = nume;
    }

    public abstract double Aria();          // fiecare formă o calculează altfel
    public override string ToString() => $"{Nume}: {Aria():F2}";
}

public class Cerc : Forma
{
    public double Raza { get; }
    public Cerc(double raza) : base("Cerc") => Raza = raza;
    public override double Aria() => Math.PI * Raza * Raza;
}

// var f = new Forma("x");   // eroare CS0144
Forma f = new Cerc(2);
Console.WriteLine(f);       // Cerc: 12,57

Constructorul bazei garantează o regulă comună tuturor formelor (numele este obligatoriu), într-un singur loc. Fiecare clasă derivată este obligată să îl apeleze, pentru că baza nu are constructor fără parametri.

Detalii utile:

  • protected comunică faptul că doar clasele derivate îl pot folosi; un constructor public într-o clasă abstractă este oricum inutilizabil din exterior, iar analizoarele (CA1012) îl semnalează
  • o clasă derivată concretă trebuie să implementeze toți membrii abstract; altfel trebuie să fie și ea abstractă
  • spre deosebire de o interfață, clasa abstractă poate ține stare (câmpuri de instanță) și poate impune ordinea de inițializare

Clasele abstracte se potrivesc când derivatele au o identitate comună și cod comun real, nu doar o listă de metode.

Ce urmărește intervievatorul: Verifică înțelegerea lanțului de constructori în moștenire. Mulți juniori răspund „nu” pentru că asociază constructorul exclusiv cu new.

Eroarea, în practică:CS0144: Cannot create instance of abstract type

27 Junior

Ce sunt inițializatorii de obiecte și ce adaugă cuvântul cheie required (C# 11)?

C#
public class Comanda
{
    public required string Client { get; init; }
    public List<string> Produse { get; } = new();
    public DateTime Data { get; init; } = DateTime.UtcNow;
}

Răspuns scurt: Inițializatorul de obiect (new Comanda { Client = "Ana" }) setează proprietăți imediat după constructor. required obligă codul care creează obiectul să seteze acea proprietate, altfel nu compilează.

Un inițializator de obiect este o scriere scurtă pentru „apelează constructorul, apoi setează aceste proprietăți”:

C#
var c = new Comanda
{
    Client = "Ana",
    Produse = { "caiet", "pix" }   // inițializator de colecție pe o proprietate get-only
};

Ordinea contează: întâi rulează constructorul, apoi atribuirile din acolade. Pentru Produse, care are doar get, sintaxa Produse = { ... } nu înlocuiește lista, ci apelează Add pe lista deja creată.

Problema veche a inițializatorilor era că nu puteai impune nimic: new Comanda() compila și lăsa Client gol. Varianta clasică era un constructor cu parametri, care devine greu de citit când ai multe proprietăți. required rezolvă asta:

C#
var ok = new Comanda { Client = "Ana" };  // compilează
var gresit = new Comanda();               // eroare CS9035: Client nu este setat

Verificarea se face la compilare, în codul care creează obiectul. Câteva detalii:

  • required se combină de obicei cu init, ca valoarea să nu mai poată fi schimbată după creare
  • dacă ai un constructor care setează toate proprietățile obligatorii, îl marchezi cu [SetsRequiredMembers] ca să nu mai fie cerute și în inițializator
  • required nu validează conținutul: Client = "" este acceptat; validarea regulilor (de exemplu non-gol) rămâne în constructor sau în setter
  • serializatoarele precum System.Text.Json respectă required din .NET 7, aruncând excepție dacă lipsește câmpul din JSON

Pentru obiecte de domeniu cu reguli puternice, un constructor rămâne cea mai clară garanție. Pentru DTO-uri și opțiuni de configurare, required cu init e mai lizibil.

Ce urmărește intervievatorul: Verifică familiaritatea cu C# modern. Un candidat bun explică ce problemă rezolvă required și unde nu este suficient.

Eroarea, în practică:JsonException: missing required properties

28 Mid

În ce ordine apar mesajele?

C#
class Baza
{
    private readonly string _b = Log("câmp Baza");
    public Baza() => Log("constructor Baza");
    protected static string Log(string m) { Console.WriteLine(m); return m; }
}

class Derivata : Baza
{
    private readonly string _d = Log("câmp Derivata");
    public Derivata() : base() => Log("constructor Derivata");
}

new Derivata();

Răspuns scurt: „câmp Derivata”, „câmp Baza”, „constructor Baza”, „constructor Derivata”. În C#, inițializatorii de câmpuri ai clasei derivate rulează înaintea apelului base(), apoi baza se construiește complet, iar la final rulează corpul constructorului derivat.

Ordinea completă la new Derivata() este:

  • inițializatorii de câmpuri din Derivata
  • apelul constructorului de bază, care rulează întâi inițializatorii de câmpuri din Baza, apoi corpul constructorului Baza
  • corpul constructorului Derivata

De aici rezultă ordinea din răspuns. Mulți candidați se așteaptă ca tot ce ține de bază să ruleze primul, cum se întâmplă în Java, unde inițializatorii de câmpuri ai derivatei rulează după constructorul bazei. Diferența dintre limbaje are consecințe reale.

De ce a ales C# această ordine: inițializatorii de câmpuri nu au acces la this (nu poți scrie _d = AltCamp.Length cu un câmp de instanță), deci rularea lor înainte de bază este sigură. Avantajul este că un câmp inițializat astfel are deja valoarea când baza, din constructorul ei, apelează o metodă virtuală suprascrisă. Câmpurile atribuite în corpul constructorului derivat, în schimb, sunt încă la valoarea implicită în acel moment.

Constructorii statici au propria ordine: rulează o singură dată, înainte de prima utilizare a tipului, iar inițializatorii statici rulează înaintea corpului constructorului static.

Merită știut și cum se înlănțuie constructorii în aceeași clasă:

C#
public class Punct
{
    public int X { get; }
    public int Y { get; }
    public Punct() : this(0, 0) { }        // delegă spre constructorul complet
    public Punct(int x, int y) { X = x; Y = y; }
}

this(...) evită dublarea logicii de inițializare. Pentru că avertismentele despre câmpuri nefolosite nu opresc compilarea, exemplul rulează așa cum e scris.

Ce urmărește intervievatorul: Este o întrebare de detaliu care arată dacă înțelegi cum se construiește un obiect. Candidații care vin din Java greșesc des ordinea.

Eroarea, în practică:CS0236: Field initializer cannot reference field

29 Mid

Ce problemă ascunsă au parametrii opționali în API-urile publice?

C#
public static decimal PretFinal(decimal pret, decimal procentReducere = 10)
    => pret - pret * procentReducere / 100;

PretFinal(200);
PretFinal(200, procentReducere: 25);

Răspuns scurt: Valoarea implicită se copiază în codul apelantului la compilare. Dacă biblioteca schimbă valoarea implicită, apelanții din alte assembly-uri folosesc tot vechea valoare până sunt recompilați.

Parametrii opționali și argumentele cu nume sunt utili pentru lizibilitate: PretFinal(200, procentReducere: 25) se citește mai bine decât PretFinal(200, 25). Dar mecanismul din spate are o consecință pe care mulți nu o cunosc.

Când scrii PretFinal(200), compilatorul transformă apelul în PretFinal(200, 10). Valoarea 10 ajunge în IL-ul apelantului, nu este citită din bibliotecă la rulare. Dacă PretFinal stă într-un pachet NuGet și autorul schimbă valoarea implicită la 15, aplicațiile care doar actualizează DLL-ul fără recompilare continuă să trimită 10. Se comportă ca o constantă const publică, cu aceeași problemă de versionare.

A doua capcană apare la moștenire: valoarea implicită se ia după tipul declarat al variabilei, nu după tipul real al obiectului:

C#
class Baza { public virtual void Scrie(string s = "baza") => Console.WriteLine(s); }
class Derivata : Baza { public override void Scrie(string s = "derivata") => Console.WriteLine(s); }

Baza b = new Derivata();
b.Scrie();             // afișează „baza”, deși rulează metoda din Derivata

Recomandări:

  • în API-uri publice sau în biblioteci, preferă supraîncărcări (PretFinal(decimal pret) => PretFinal(pret, ReducereImplicita)), unde valoarea implicită rămâne în bibliotecă
  • dacă folosești parametri opționali, alege valori care nu se vor schimba (null, false, CancellationToken ct = default)
  • nu pune valori implicite diferite la override față de bază; analizoarele te avertizează
  • prea mulți parametri opționali sugerează că ai nevoie de un obiect de opțiuni

În codul intern al unei aplicații, unde totul se recompilează împreună, problema de versionare nu apare.

Ce urmărește intervievatorul: Verifică dacă știi cum funcționează mecanismul la nivel de compilare. Este o întrebare care separă utilizarea limbajului de proiectarea de API-uri.

Eroarea, în practică:CS1737: Optional parameters must come after requiredCS1736: Default parameter value must be a constant

30 Mid

Unde este bug-ul și cum îl repari?

C#
public class Punct
{
    public int X { get; set; }
    public int Y { get; set; }
    public override bool Equals(object? obj) => obj is Punct p && p.X == X && p.Y == Y;
}

var vizitate = new HashSet<Punct> { new Punct { X = 1, Y = 2 } };
Console.WriteLine(vizitate.Contains(new Punct { X = 1, Y = 2 }));

Răspuns scurt: Equals este suprascris, dar GetHashCode nu, așa că două puncte egale au hash-uri diferite și HashSet aproape sigur nu le găsește: afișează False. Suprascrii și GetHashCode cu aceleași câmpuri, de exemplu cu HashCode.Combine(X, Y).

HashSet<T> și Dictionary<TKey, TValue> caută un element în doi pași: calculează GetHashCode() ca să găsească „sertarul” (bucket-ul), apoi compară cu Equals doar elementele din acel sertar. Implementarea implicită a lui GetHashCode pentru clase depinde de identitatea obiectului, deci două instanțe distincte cu aceleași coordonate ajung aproape sigur în sertare diferite. Equals nu mai apucă să fie apelat.

Contractul este: dacă a.Equals(b) este adevărat, atunci a.GetHashCode() == b.GetHashCode(). Invers nu e obligatoriu (coliziunile sunt permise). Compilatorul te avertizează (CS0659) când suprascrii doar Equals.

Reparația:

C#
public sealed class Punct : IEquatable<Punct>
{
    public int X { get; init; }
    public int Y { get; init; }

    public bool Equals(Punct? p) => p is not null && p.X == X && p.Y == Y;
    public override bool Equals(object? obj) => Equals(obj as Punct);
    public override int GetHashCode() => HashCode.Combine(X, Y);
}

Am schimbat și set în init. Motivul este a doua problemă din codul original: dacă modifici X după ce obiectul a fost pus în HashSet, hash-ul lui se schimbă, dar el rămâne în sertarul vechi. Obiectul devine imposibil de găsit sau de șters, deși este în colecție. Cheile din colecții bazate pe hash trebuie să fie imutabile, cel puțin în câmpurile folosite la egalitate.

Cea mai simplă soluție în C# modern este public record Punct(int X, int Y);: compilatorul generează corect Equals, GetHashCode, == și !=, iar proprietățile sunt init.

Ce urmărește intervievatorul: Testează contractul dintre Equals și GetHashCode, foarte des încălcat. Candidații buni observă și problema cheilor mutabile.

31 Mid

Scrie un tip Bani care să permită a + b și a == b. Ce reguli trebuie respectate când supraîncarci operatori?

Răspuns scurt: Declari operatori public static în tip; == trebuie însoțit de !=, iar când le definești suprascrii și Equals și GetHashCode. Operatorii trebuie să aibă sensul evident, de exemplu adunarea sumelor în aceeași monedă.

Un tip valoare imutabil pentru bani este un exemplu bun, pentru că adunarea are un sens natural, dar și o regulă (aceeași monedă):

C#
public readonly struct Bani : IEquatable<Bani>
{
    public decimal Suma { get; }
    public string Moneda { get; }

    public Bani(decimal suma, string moneda) { Suma = suma; Moneda = moneda; }

    public static Bani operator +(Bani a, Bani b)
    {
        if (a.Moneda != b.Moneda)
            throw new InvalidOperationException($"Nu poți aduna {a.Moneda} cu {b.Moneda}");
        return new Bani(a.Suma + b.Suma, a.Moneda);
    }

    public static bool operator ==(Bani a, Bani b) => a.Equals(b);
    public static bool operator !=(Bani a, Bani b) => !a.Equals(b);

    public bool Equals(Bani o) => Suma == o.Suma && Moneda == o.Moneda;
    public override bool Equals(object? obj) => obj is Bani b && Equals(b);
    public override int GetHashCode() => HashCode.Combine(Suma, Moneda);
}

var total = new Bani(10, "RON") + new Bani(5.5m, "RON");
total += new Bani(1, "RON");
Console.WriteLine(total.Suma);                 // 16,5

Regulile limbajului:

  • operatorii sunt public static, iar cel puțin un parametru trebuie să fie tipul care îi declară
  • unii vin în perechi obligatorii: == cu !=, < cu >, <= cu >= (altfel eroarea CS0216)
  • operatorii compuși (+=) nu se declară separat până la C# 14; sunt derivați din cei simpli
  • când definești ==, compilatorul te avertizează dacă nu suprascrii și Equals/GetHashCode, pentru ca toate formele de egalitate să fie consistente

Regula de design: supraîncarcă operatori doar când sensul este evident pentru oricine citește codul. comanda + produs este ambiguu; o metodă Adauga este mai clară.

Ce urmărește intervievatorul: Verifică dacă știi regulile tehnice și dacă păstrezi consistența egalității. Un candidat bun discută și când operatorii fac codul mai puțin clar.

Eroarea, în practică:CS0216: The operator requires a matching operator

32 Mid

Ce problemă de încapsulare are clasa următoare și cum ai rescrie-o?

C#
public class Cos
{
    public List<Produs> Produse { get; set; } = new();
    public decimal Total { get; private set; }

    public void Adauga(Produs p)
    {
        Produse.Add(p);
        Total += p.Pret;
    }
}

Răspuns scurt: Lista este expusă direct, deci oricine poate face cos.Produse.Add(...), Clear() sau o poate înlocui, iar Total devine greșit. Ascunzi lista, expui o vedere doar de citire și calculezi totalul din date.

Clasa are o regulă internă (un invariant): Total este suma prețurilor din listă. Codul o respectă doar dacă toată lumea trece prin Adauga. Dar lista este publică și mutabilă:

C#
cos.Produse.Add(new Produs("Laptop", 3000)); // Total nu se schimbă
cos.Produse.Clear();                           // Total rămâne vechi
cos.Produse = new List<Produs>();              // setter public

private set pe Total dă o impresie de siguranță, dar starea poate fi stricată prin listă. Rescrierea:

C#
public class Cos
{
    private readonly List<Produs> _produse = new();

    public IReadOnlyList<Produs> Produse => _produse;
    public decimal Total => _produse.Sum(p => p.Pret);

    public void Adauga(Produs p)
    {
        ArgumentNullException.ThrowIfNull(p);
        if (_produse.Count >= 50)
            throw new InvalidOperationException("Coșul este plin");
        _produse.Add(p);
    }

    public bool Elimina(Produs p) => _produse.Remove(p);
}

public record Produs(string Nume, decimal Pret);

Ce s-a schimbat:

  • câmpul este privat și readonly: nu mai poate fi înlocuit
  • exteriorul vede IReadOnlyList<T>: poate citi și parcurge, nu poate modifica
  • Total este calculat, deci nu poate deveni inconsistent; dacă ar fi costisitor, l-ai actualiza doar în Adauga/Elimina, care sunt singurele căi de modificare
  • regulile (validarea, limita) sunt într-un singur loc

O nuanță: IReadOnlyList este doar o interfață, iar cineva poate face cast înapoi la List<Produs>. Pentru cod intern este suficient; pentru o bibliotecă publică poți întoarce _produse.AsReadOnly(), un wrapper care nu poate fi modificat. Iar elementele trebuie să fie și ele imutabile (aici record cu proprietăți init), altfel cineva ar putea schimba prețul unui produs deja adăugat.

Ce urmărește intervievatorul: Verifică dacă înțelegi încapsularea dincolo de „câmpuri private, proprietăți publice”. Puțini observă că o colecție expusă strică invariantul.

33 Senior

Ce se întâmplă la rularea codului următor?

C#
class Baza
{
    public Baza() => Initializeaza();
    protected virtual void Initializeaza() => Console.WriteLine("Baza");
}

class Raport : Baza
{
    private readonly string _titlu;
    public Raport(string titlu) { _titlu = titlu; }
    protected override void Initializeaza() => Console.WriteLine(_titlu.ToUpper());
}

new Raport("vânzări");

Răspuns scurt: Aruncă NullReferenceException. Constructorul bazei apelează versiunea suprascrisă din Raport, dar corpul constructorului Raport nu a rulat încă, deci _titlu este null. De aceea nu apelezi metode virtuale din constructori.

În C#, tipul real al obiectului este stabilit de la început: chiar în timp ce rulează constructorul Baza, obiectul este deja un Raport. Un apel virtual din constructorul bazei ajunge deci la Raport.Initializeaza. Numai că ordinea de construcție este: inițializatori de câmpuri din Raport, constructorul Baza, apoi corpul constructorului Raport. Atribuirea _titlu = titlu nu s-a întâmplat încă, deci _titlu.ToUpper() aruncă excepție.

Comportamentul diferă de C++, unde, în constructorul bazei, apelurile virtuale ajung la versiunea din bază. Programatorii care vin din C++ se așteaptă să vadă „Baza”.

Un detaliu care arată înțelegere: dacă _titlu ar fi inițializat direct la declarare (private readonly string _titlu = "implicit";), excepția nu ar apărea, pentru că inițializatorii de câmpuri ai derivatei rulează înaintea constructorului de bază. Dar parametrii constructorului nu sunt disponibili în inițializatori, deci nu e o soluție generală.

Soluții:

  • nu apela membri virtuali sau abstracți din constructori; analizorul CA2214 semnalează asta
  • dacă baza are nevoie de date de la derivată, le cere prin parametrii constructorului: public Raport(string titlu) : base(titlu)
  • dacă inițializarea trebuie personalizată, separ-o de construcție: o metodă fabrică statică creează obiectul complet, apoi apelează inițializarea
C#
public static Raport Creeaza(string titlu)
{
    var r = new Raport(titlu);
    r.Initializeaza();
    return r;
}

Problema este clasică în framework-uri cu clase de bază extensibile: autorul bazei nu controlează ce face suprascrierea, iar derivata nu știe că este apelată pe un obiect pe jumătate construit.

Ce urmărește intervievatorul: Verifică înțelegerea profundă a construcției obiectelor și a dispatch-ului virtual. Un senior explică și de ce rezultatul diferă de C++ și cum previi problema.

Eroarea, în practică:NullReferenceException: Object reference not set

34 Senior

Ai o clasă Punct cu Equals suprascris și o clasă derivată PunctColorat care adaugă culoarea în comparație. Ce problemă apare și cum implementezi corect egalitatea într-o ierarhie?

Răspuns scurt: Egalitatea devine nesimetrică: punct.Equals(punctColorat) poate fi adevărat, iar invers fals, ceea ce strică colecțiile. Compari și tipul exact (GetType()), sigilezi clasele sau folosești record, care face asta automat.

Implementarea tipică, scrisă fără atenție:

C#
public class Punct
{
    public int X { get; init; }
    public int Y { get; init; }
    public override bool Equals(object? o) => o is Punct p && p.X == X && p.Y == Y;
    public override int GetHashCode() => HashCode.Combine(X, Y);
}

public class PunctColorat : Punct
{
    public string Culoare { get; init; } = "";
    public override bool Equals(object? o) =>
        o is PunctColorat p && base.Equals(p) && p.Culoare == Culoare;
    public override int GetHashCode() => HashCode.Combine(base.GetHashCode(), Culoare);
}

var p = new Punct { X = 1, Y = 1 };
var pc = new PunctColorat { X = 1, Y = 1, Culoare = "roșu" };
Console.WriteLine(p.Equals(pc));  // True: pc este un Punct
Console.WriteLine(pc.Equals(p));  // False: p nu este PunctColorat

Contractul lui Equals cere simetrie (a.Equals(b) ⇔ b.Equals(a)) și tranzitivitate. Altfel, Contains, Distinct sau un Dictionary dau rezultate care depind de ordinea comparațiilor.

Soluții, în ordinea în care le-aș propune:

  • clase sealed: dacă nu există derivate, problema dispare
  • verificarea tipului exact: o is not null && o.GetType() == GetType() && ... în bază; un Punct nu mai este egal niciodată cu un PunctColorat
  • record-uri: compilatorul generează o proprietate ascunsă EqualityContract care întoarce tipul, iar Equals o compară; record PunctColorat(int X, int Y, string Culoare) : Punct(X, Y) se comportă corect fără cod scris de mână

De obicei, un punct colorat nu ar trebui să fie „egal” cu unul necolorat; compunerea (PunctColorat care conține un Punct) evită problema.

Ce urmărește intervievatorul: Testează cunoașterea contractului de egalitate și a felului în care record-urile îl rezolvă. Un senior leagă problema de alegerea între moștenire și compunere.

Interfețe, struct și record

35 Junior

Cum sortezi o listă de obiecte proprii după mai multe criterii? Care e diferența dintre IComparable<T> și IComparer<T>?

Răspuns scurt: IComparable<T> definește ordinea „naturală” în interiorul clasei (CompareTo), iar IComparer<T> este un obiect separat care definește o ordine alternativă. List.Sort le acceptă pe amândouă, plus o lambda Comparison<T>.

IComparable<T> se implementează în tipul însuși și spune care este ordinea implicită:

C#
public class Student : IComparable<Student>
{
    public string Nume { get; init; } = "";
    public double Media { get; init; }

    public int CompareTo(Student? alt) =>
        alt is null ? 1 : Media.CompareTo(alt.Media);
}

public class DupaNume : IComparer<Student>
{
    public int Compare(Student? a, Student? b) =>
        string.Compare(a?.Nume, b?.Nume, StringComparison.CurrentCulture);
}

var studenti = new List<Student>
{
    new() { Nume = "Ion", Media = 8.5 },
    new() { Nume = "Ana", Media = 9.7 }
};
studenti.Sort();                                       // după medie, crescător
studenti.Sort(new DupaNume());                         // după nume
studenti.Sort((a, b) => b.Media.CompareTo(a.Media));   // descrescător, cu lambda

CompareTo întoarce un număr negativ dacă obiectul curent e „mai mic”, zero dacă sunt egale și pozitiv dacă e „mai mare”. Fără IComparable<T>, studenti.Sort() aruncă InvalidOperationException, pentru că nu știe cum să compare.

IComparer<T> este util când același tip are mai multe ordini legitime sau când nu poți modifica clasa. Se folosește și la SortedSet<T> și SortedDictionary<TKey, TValue>.

Pentru mai multe criterii, LINQ este de obicei mai lizibil:

C#
var ordonati = studenti.OrderByDescending(s => s.Media).ThenBy(s => s.Nume).ToList();

Două capcane:

  • nu scrie comparația ca a.Varsta - b.Varsta; la valori mari scăderea poate depăși int și inversa semnul; folosește CompareTo
  • List.Sort nu este stabil (elementele egale își pot schimba ordinea), pe când OrderBy este stabil

Ce urmărește intervievatorul: Verifică dacă poți sorta obiecte proprii în mai multe feluri. Greșeala tipică este comparația prin scădere sau confuzia dintre cele două interfețe.

Eroarea, în practică:Failed to compare two elements in the array

36 Junior

Ce afișează codul următor cu record-uri?

C#
public record Echipa(string Nume, List<string> Membri);

var e1 = new Echipa("A", new List<string> { "Ana" });
var e2 = e1 with { Nume = "B" };
e2.Membri.Add("Ion");

Console.WriteLine(e1.Membri.Count);
Console.WriteLine(e1 == new Echipa("A", e1.Membri));
Console.WriteLine(e1 == new Echipa("A", new List<string> { "Ana", "Ion" }));

Răspuns scurt: Afișează 2, True și False. with face o copie superficială, deci ambele record-uri împart aceeași listă, iar egalitatea generată compară lista prin referință, nu după conținut.

Un record generează egalitate pe valori: două instanțe sunt egale dacă au aceleași valori în toate proprietățile, comparate cu EqualityComparer<T>.Default. Pentru string asta înseamnă conținutul, dar pentru List<string> înseamnă referința, pentru că List<T> nu suprascrie Equals.

Pas cu pas:

  • e1 with { Nume = "B" } creează un record nou, copiind fiecare proprietate. Copia este superficială (shallow): e2.Membri referă aceeași listă ca e1.Membri
  • e2.Membri.Add("Ion") modifică lista comună, deci e1.Membri.Count este 2
  • comparația cu un record care are același nume și aceeași instanță de listă: True
  • comparația cu o listă nouă, chiar cu același conținut: False

Concluzia practică: un record este „imutabil” doar la primul nivel. Proprietățile init nu pot fi reatribuite, dar obiectele mutabile din interior pot fi modificate. Pentru imutabilitate reală și egalitate pe conținut ai câteva opțiuni:

C#
public record Echipa(string Nume, IReadOnlyList<string> Membri)
{
    public virtual bool Equals(Echipa? alt) =>
        alt is not null && Nume == alt.Nume && Membri.SequenceEqual(alt.Membri);

    public override int GetHashCode() => HashCode.Combine(Nume, Membri.Count);
}

Alternativ, folosești ImmutableArray<string> sau ImmutableList<string> și construiești o listă nouă la fiecare with: e1 with { Membri = e1.Membri.Add("Ion") }. Ca regulă, record-urile funcționează cel mai bine cu proprietăți de tipuri simple sau alte record-uri, unde egalitatea pe valori se propagă natural.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce înseamnă concret egalitatea pe valori și with. Mulți presupun că un record este imutabil și comparat în profunzime.

37 Junior

Un coleg te întreabă când să folosească un tuplu, un tip anonim, un record sau o clasă obișnuită pentru niște date. Cum i-ai explica?

Răspuns scurt: Alegerea ține de cât de departe călătoresc datele: tip anonim în interiorul unei metode (de obicei în LINQ), tuplu pentru a întoarce câteva valori dintr-o metodă privată, record pentru date cu sens în domeniu, clasă pentru obiecte cu comportament și stare care se schimbă.

Un model de răspuns structurat, de la cel mai local la cel mai durabil:

  • Tip anonim (new { c.Nume, Total = 5 }): există doar în metoda în care e creat, pentru că nu are nume pe care să-l poți scrie într-o semnătură. Locul lui natural este o proiecție LINQ intermediară. Proprietățile sunt doar de citire, iar egalitatea este pe valori
  • Tuplu ((string Nume, int Varsta)): îl poți întoarce dintr-o metodă și deconstrui ușor. Potrivit pentru 2–3 valori legate temporar, în cod privat. Numele câmpurilor nu există la rulare, deci serializarea în JSON dă Item1, Item2
  • record: un tip cu nume, egalitate pe valori, ToString util și with. Potrivit pentru DTO-uri, mesaje, evenimente, valori de domeniu (Adresa, Interval), adică date care nu au identitate proprie
  • clasă: pentru obiecte cu identitate și comportament, a căror stare evoluează după reguli (ContBancar, Comanda); egalitatea implicită pe referință este corectă aici, pentru că două conturi cu același sold nu sunt același cont
C#
var top = vanzari.GroupBy(v => v.Produs)
                 .Select(g => new { Produs = g.Key, Total = g.Sum(v => v.Suma) }) // anonim
                 .OrderByDescending(x => x.Total).First();

static (int Min, int Max) Interval(int[] v) => (v.Min(), v.Max());             // tuplu

public record AdresaLivrare(string Oras, string Strada, string CodPostal);    // record

I-aș da colegului și un semnal practic: dacă începi să pui același tuplu în trei semnături, este timpul pentru un record. Iar dacă un record începe să aibă metode care îi schimbă starea și reguli de validare, probabil e o clasă de domeniu.

Ce urmărește intervievatorul: Întrebare de situație: verifică dacă poți explica un concept cu criterii clare și exemple. Un răspuns bun arată judecata, nu o listă de definiții.

38 Junior

Ce afișează codul următor (C# 10 sau mai nou)? Ce restricții are un struct față de o clasă?

C#
public struct Punct
{
    public int X { get; set; }
    public Punct() { X = -1; }
}

var p1 = new Punct();
var p2 = default(Punct);
var tablou = new Punct[2];
Console.WriteLine($"{p1.X} {p2.X} {tablou[0].X}");

Răspuns scurt: Afișează „-1 0 0”. Din C# 10, un struct poate avea constructor fără parametri, dar default și tablourile nu îl apelează: pun memoria pe zero. Un struct nu poate moșteni și nu poate fi moștenit, dar poate implementa interfețe.

Până în C# 10, new Punct() pentru un struct însemna mereu „toate câmpurile pe zero”. C# 10 permite un constructor explicit fără parametri, iar new Punct() îl apelează. Există însă situații în care runtime-ul creează valori de struct fără să ruleze niciun constructor:

  • default(Punct) sau default dintr-o metodă generică
  • elementele unui tablou nou: new Punct[2]
  • câmpurile unei clase de tip Punct, înainte de atribuire

Toate acestea produc valoarea cu memoria pe zero, deci X este 0. De aceea un struct trebuie proiectat astfel încât starea „toate câmpurile zero” să fie validă sau măcar recunoscută.

Restricțiile unui struct față de o clasă:

  • nu poate moșteni dintr-o altă clasă sau struct (moștenește implicit din System.ValueType) și nu poate fi moștenit (este implicit sealed)
  • poate implementa interfețe, dar folosirea lui printr-o variabilă de tip interfață îl împachetează (boxing)
  • atribuirea și transmiterea ca parametru copiază întreaga valoare
  • nu poate avea finalizer
  • nu poate fi null, decât ca Nullable<T> (Punct?)
C#
var a = new Punct();
var b = a;     // copie
b.X = 10;
Console.WriteLine(a.X); // -1: a nu e afectat

Recomandarea Microsoft este ca struct-urile să fie mici, imutabile și să reprezinte o singură valoare logică (coordonate, intervale, bani), cu readonly struct sau readonly record struct. Un struct mutabil cu proprietăți set, ca în exemplu, este bun pentru ilustrat regulile, dar produce bug-uri de copiere în cod real.

Ce urmărește intervievatorul: Verifică înțelegerea semanticii struct-urilor și a C# 10. Puțini candidați știu că default și tablourile ocolesc constructorul.

39 Mid

O clasă implementează două interfețe care au o metodă cu același nume. Ce afișează codul următor și ce este implementarea explicită?

C#
interface IFisier { void Salveaza(); }
interface IBazaDate { void Salveaza(); }

class Document : IFisier, IBazaDate
{
    public void Salveaza() => Console.WriteLine("comun");
    void IBazaDate.Salveaza() => Console.WriteLine("în baza de date");
}

var d = new Document();
d.Salveaza();
((IFisier)d).Salveaza();
((IBazaDate)d).Salveaza();

Răspuns scurt: Afișează „comun”, „comun” și „în baza de date”. Metoda scrisă ca IBazaDate.Salveaza este o implementare explicită: se apelează doar printr-o referință de tipul acelei interfețe și nu face parte din API-ul public al clasei.

O metodă publică obișnuită poate satisface simultan toate interfețele care declară aceeași semnătură. Aici public void Salveaza() implementează IFisier.Salveaza și ar fi implementat și IBazaDate.Salveaza, dacă nu ar exista varianta explicită.

Implementarea explicită se scrie cu numele interfeței în față și fără modificator de acces. Ea are două efecte:

  • membrul nu e vizibil prin tipul clasei: d.Salveaza() apelează metoda publică
  • membrul este apelat doar printr-o referință de tipul interfeței: ((IBazaDate)d).Salveaza()

Când e utilă:

  • conflicte de nume, ca în exemplu, unde cele două operații au sensuri diferite
  • ascunderea unor membri care nu au sens în API-ul principal; List<T> implementează explicit ICollection.SyncRoot și IList.Add(object), ca să nu-ți apară în IntelliSense
  • implementarea variantei negeneric când implementezi IEnumerable<T>:
C#
public class Colectie : IEnumerable<int>
{
    private readonly List<int> _date = new();
    public IEnumerator<int> GetEnumerator() => _date.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); // explicit
}
  • metode cu același nume care trebuie să întoarcă tipuri diferite

Dezavantaje: apelul necesită cast sau o variabilă de tip interfață, ceea ce surprinde utilizatorii clasei. Pentru un struct, cast-ul la interfață produce boxing, deci apelul unui membru explicit pe un struct alocă un obiect, cu excepția situației în care e făcut printr-un parametru generic constrâns la acea interfață.

Ca regulă, implementarea explicită este o unealtă pentru cazuri speciale, nu stilul implicit de a implementa interfețe.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum se leagă membrii clasei de interfețe. Exemplul cu IEnumerable<T> arată dacă ai implementat colecții proprii.

40 Mid

Ce sunt default interface methods (C# 8)? Ce afișează și ce nu compilează în codul următor?

C#
public interface IJurnal
{
    void Scrie(string mesaj);
    void ScrieEroare(Exception ex) => Scrie($"EROARE: {ex.Message}");
}

public class JurnalConsola : IJurnal
{
    public void Scrie(string mesaj) => Console.WriteLine(mesaj);
}

var j = new JurnalConsola();
j.ScrieEroare(new Exception("disc plin"));
IJurnal ij = j;
ij.ScrieEroare(new Exception("disc plin"));

Răspuns scurt: Linia j.ScrieEroare(...) nu compilează: o metodă implicită din interfață nu devine membru al clasei. Prin variabila de tip IJurnal funcționează și afișează „EROARE: disc plin”.

Din C# 8 (și .NET Core 3.0), o interfață poate conține membri cu implementare. Scopul principal este evoluția interfețelor fără să strici implementările existente: dacă adaugi ScrieEroare într-o interfață publică folosită de alte echipe, toate clasele care o implementează ar înceta să compileze. Cu o implementare implicită, ele continuă să funcționeze și pot suprascrie metoda dacă vor.

Regula care surprinde: membrul implicit aparține interfeței, nu clasei. Clasa JurnalConsola nu are o metodă ScrieEroare, deci apelul prin variabila de tip clasă dă eroarea CS1061. Prin IJurnal apelul merge și folosește implementarea din interfață, care apelează Scrie din clasă.

Dacă clasa vrea alt comportament, implementează metoda normal:

C#
public class JurnalFisier : IJurnal
{
    public void Scrie(string mesaj) => File.AppendAllText("app.log", mesaj + Environment.NewLine);
    public void ScrieEroare(Exception ex) => Scrie($"EROARE: {ex}"); // include stack trace
}

Alte lucruri pe care interfețele le pot avea în C# modern:

  • membri statici, constante și membri privați folosiți de implementările implicite
  • membri statici abstracți (C# 11): static abstract T Zero { get; }, baza pentru generic math (INumber<T>), care permite metode generice cu operatori

Ce nu pot avea: câmpuri de instanță. Deci o interfață nu devine o clasă abstractă; nu poate ține stare.

În practică, metodele implicite se folosesc moderat: pentru extinderea API-urilor publice sau pentru comportament mic derivat din ceilalți membri. Logica mare stă tot în clase sau în metode de extensie.

Ce urmărește intervievatorul: Verifică dacă știi ce problemă rezolvă funcționalitatea și regula de vizibilitate. Mulți candidați cred că metoda implicită apare în clasă.

41 Mid

Care este diferența dintre record, record struct și readonly record struct? Compilează linia p.X = 5?

C#
public record struct Punct(int X, int Y);

var p = new Punct(1, 2);
p.X = 5;

Răspuns scurt: Da, compilează: la record struct (C# 10), proprietățile poziționale sunt get; set;, deci mutabile. record (clasă) are proprietăți init, iar readonly record struct generează proprietăți doar de citire și interzice orice modificare.

Toate trei generează egalitate pe valori, ToString, deconstrucție și suport pentru with. Diferă prin semantica de bază și prin mutabilitate:

  • record (sau record class): tip referință. Proprietățile poziționale sunt { get; init; }. Suportă moștenire între record-uri, iar egalitatea include tipul exact (prin EqualityContract)
  • record struct: tip valoare. Proprietățile poziționale sunt { get; set; }, deci mutabile, o alegere făcută pentru consistență cu tuplurile. Nu suportă moștenire
  • readonly record struct: tip valoare, proprietăți { get; init; }, iar compilatorul impune ca toți membrii să nu modifice starea
C#
public record Persoana(string Nume);               // referință, imutabil la primul nivel
public record struct Punct(int X, int Y);          // valoare, mutabil
public readonly record struct Interval(DateOnly Start, DateOnly Sfarsit); // valoare, imutabil

var i = new Interval(new DateOnly(2026, 1, 1), new DateOnly(2026, 1, 31));
// i.Start = ...;           // eroare
var j = i with { Sfarsit = new DateOnly(2026, 2, 28) }; // copie modificată

Cum alegi:

  • record pentru DTO-uri, mesaje, rezultate de API, obiecte care pot fi mari sau care sunt partajate des
  • readonly record struct pentru valori mici (câțiva octeți), create în număr mare, unde vrei să eviți alocările pe heap: coordonate, intervale, identificatori puternic tipizați (readonly record struct ClientId(Guid Valoare);)
  • record struct mutabil rar; mutabilitatea la tipuri valoare produce bug-uri de copiere (modifici o copie, nu originalul)

Un detaliu pentru interviu: default(Interval) există mereu, cu valorile pe zero, chiar dacă ai validări în constructor. La un record class, echivalentul ar fi null.

Ce urmărește intervievatorul: Verifică dacă știi diferențele generate de compilator, nu doar că „există și record struct”. Mutabilitatea implicită a record struct surprinde des.

42 Mid

Ce sunt constructorii primari pentru clase (C# 12) și prin ce diferă de cei ai record-urilor?

C#
public class ServiciuComenzi(IRepositoryComenzi repo, INotificari notificari)
{
    public async Task PlaseazaAsync(Comanda c)
    {
        await repo.SalveazaAsync(c);
        await notificari.TrimiteAsync(c.Client, "Comanda a fost plasată");
    }
}

Răspuns scurt: Parametrii din antetul clasei sunt disponibili în tot corpul clasei, fără câmpuri declarate explicit. Spre deosebire de record, nu generează proprietăți publice, egalitate sau Deconstruct, iar parametrii capturați sunt mutabili.

C# 12 a extins constructorii primari, existenți la record-uri din C# 9, la orice clasă și struct. În exemplu, repo și notificari sunt parametri ai constructorului, iar compilatorul îi păstrează automat într-un câmp ascuns, pentru că sunt folosiți într-o metodă. Pentru serviciile care primesc dependențe prin injecție, elimină mult cod repetitiv.

Diferențele față de un record:

  • la record Persoana(string Nume), Nume devine proprietate publică; la o clasă, parametrul rămâne privat și nu poate fi accesat din exterior
  • clasa nu primește egalitate pe valori, ToString generat sau Deconstruct
  • parametrul capturat nu este readonly: poți scrie repo = null; într-o metodă și compilează

Ultimul punct este principalul argument împotriva folosirii lor fără atenție. Dacă vrei garanția de readonly, inițializezi explicit un câmp:

C#
public class ServiciuComenzi(IRepositoryComenzi repo)
{
    private readonly IRepositoryComenzi _repo = repo ?? throw new ArgumentNullException(nameof(repo));
}

Când un parametru este folosit și pentru a inițializa un câmp, și direct într-o metodă, compilatorul îl stochează de două ori și dă avertismentul CS9124. Alege un singur mod de utilizare.

Alte detalii:

  • orice alt constructor declarat în clasă trebuie să apeleze constructorul primar cu : this(...)
  • validarea parametrilor se face în inițializatorii de câmpuri sau proprietăți, pentru că nu există un corp de constructor
  • clasa derivată poate transmite parametrii către bază: class Admin(string nume) : Utilizator(nume)

În multe echipe .NET, regula este: constructori primari pentru servicii simple cu dependențe injectate, constructori clasici pentru clasele de domeniu cu validări.

Ce urmărește intervievatorul: Verifică familiaritatea cu C# 12 și cunoașterea capcanelor. Un candidat bun pomenește lipsa lui readonly și avertismentul despre dubla capturare.

43 Senior

De ce ar trebui un struct folosit drept cheie în Dictionary să implementeze IEquatable<T> și să suprascrie GetHashCode?

Răspuns scurt: Fără ele, se folosesc ValueType.Equals și ValueType.GetHashCode, care pot recurge la reflecție, împachetează valoarea la fiecare comparație și pot produce un hash slab. IEquatable<T> permite comparații fără boxing și cu cost previzibil.

Orice struct moștenește Equals(object) și GetHashCode() din System.ValueType. Implementările implicite sunt generale, deci lente:

  • Equals(object) primește un object, deci valoarea comparată trebuie împachetată (boxing), adică alocată pe heap
  • dacă struct-ul conține referințe sau are spații între câmpuri, comparația câmp cu câmp se face prin reflecție
  • GetHashCode implicit se poate baza doar pe primul câmp nenul (comportamentul exact ține de implementare), ceea ce produce multe coliziuni când primul câmp are puține valori distincte

Dictionary<TKey, TValue> și HashSet<T> folosesc EqualityComparer<T>.Default. Dacă T implementează IEquatable<T>, comparatorul apelează direct Equals(T), fără boxing:

C#
public readonly struct CheieStoc : IEquatable<CheieStoc>
{
    public int DepozitId { get; }
    public string Sku { get; }

    public CheieStoc(int depozitId, string sku) { DepozitId = depozitId; Sku = sku; }

    public bool Equals(CheieStoc alt) => DepozitId == alt.DepozitId && Sku == alt.Sku;
    public override bool Equals(object? obj) => obj is CheieStoc c && Equals(c);
    public override int GetHashCode() => HashCode.Combine(DepozitId, Sku);
}

var stoc = new Dictionary<CheieStoc, int>();
stoc[new CheieStoc(1, "CAIET-A5")] = 120;

Cea mai scurtă variantă corectă este readonly record struct CheieStoc(int DepozitId, string Sku);, care generează aceste membri automat. Un tuplu (int, string) ca cheie este și el corect, pentru că ValueTuple implementează IEquatable.

Cum ai demonstra diferența: un benchmark cu BenchmarkDotNet și [MemoryDiagnoser] arată alocările făcute la fiecare căutare în varianta fără IEquatable<T>. Într-un dicționar folosit intens, alocările acestea cresc presiunea pe garbage collector. Analizorul CA1815 semnalează struct-urile care nu suprascriu egalitatea.

Ce urmărește intervievatorul: Testează cunoașterea costurilor ascunse ale tipurilor valoare. Un senior știe de ce contează și cum ar măsura efectul.

44 Senior

Ce afișează metoda Test și de ce? Ce sunt copiile defensive?

C#
public struct Contor
{
    public int Valoare;
    public void Incrementeaza() => Valoare++;
}

public class Gazda
{
    private readonly Contor _contor;

    public void Test()
    {
        _contor.Incrementeaza();
        _contor.Incrementeaza();
        Console.WriteLine(_contor.Valoare);
    }
}

Răspuns scurt: Afișează 0. Câmpul este readonly, iar compilatorul nu poate garanta că Incrementeaza nu modifică struct-ul, așa că apelează metoda pe o copie temporară (copie defensivă). Modificările se pierd.

Un câmp readonly de tip struct nu poate fi modificat după constructor. Dar Incrementeaza este o metodă obișnuită, care ar putea modifica this. Ca să respecte garanția de readonly fără să interzică apelul, compilatorul copiază valoarea într-o variabilă temporară și apelează metoda pe copie. Fiecare apel incrementează o altă copie, care apoi dispare, iar câmpul rămâne 0.

Aceeași copie defensivă apare în alte situații:

  • la parametrii in (transmiși prin referință doar pentru citire)
  • la apelarea unei metode pe un câmp readonly de tip struct, ca aici

Două probleme distincte rezultă de aici:

  • corectitudine: modificările dispar fără nicio eroare de compilare, ca în exemplu
  • performanță: pentru un struct mare (de exemplu 64 de octeți), fiecare apel de metodă sau proprietate copiază toată valoarea, deși ai folosit in sau readonly tocmai ca să eviți copierea

Soluții:

C#
public readonly struct Interval
{
    public int Start { get; }
    public int Sfarsit { get; }
    public Interval(int start, int sfarsit) { Start = start; Sfarsit = sfarsit; }
    public int Lungime => Sfarsit - Start;   // fără copie: tipul e readonly
}

public struct Vector
{
    public double X, Y;
    public readonly double Lungime() => Math.Sqrt(X * X + Y * Y); // membru readonly (C# 8)
}

Un readonly struct sau un membru marcat readonly îi spune compilatorului că metoda nu modifică starea, deci copia nu mai e necesară. Pentru exemplul inițial, soluția corectă este fie să elimini readonly de pe câmp, fie, mai bine, să faci struct-ul imutabil.

Ce urmărește intervievatorul: Verifică înțelegerea fină a tipurilor valoare și a interacțiunii cu readonly. Un senior leagă problema de recomandarea struct-urilor imutabile.

Eroarea, în practică:CS1612: Cannot modify the return value

Generice și colecții

45 Junior

De ce folosim List<int> în loc de ArrayList? Ce problemă rezolvă genericele?

Răspuns scurt: Genericele dau siguranță de tip la compilare și evită boxing-ul: List<int> acceptă doar int și le stochează direct, pe când ArrayList stochează object, deci împachetează fiecare număr și cere cast la citire.

Înainte de .NET 2.0, colecțiile erau construite peste object. Orice valoare putea fi adăugată, iar la citire trebuia să faci cast:

C#
var vechi = new ArrayList { 1, 2, "trei" };   // compilează
int suma = 0;
foreach (object o in vechi)
    suma += (int)o;                           // InvalidCastException la "trei"

var nou = new List<int> { 1, 2 };
// nou.Add("trei");                           // eroare de compilare
foreach (int n in nou) suma += n;              // fără cast

Genericele rezolvă trei probleme:

  • siguranța de tip: greșeala este prinsă la compilare, nu la rulare, eventual la un client
  • performanța: în ArrayList, fiecare int este împachetat într-un obiect pe heap (boxing), iar la citire este despachetat; List<int> ține valorile direct într-un tablou int[], fără alocări suplimentare
  • reutilizarea: scrii o singură dată Stiva<T> sau Cache<TKey, TValue> și funcționează corect pentru orice tip

Un detaliu care diferențiază .NET de Java: genericele din .NET sunt păstrate la rulare (reified). List<int> și List<string> sunt tipuri distincte, iar pentru tipurile valoare JIT-ul generează cod specializat, fără conversii. În Java, prin type erasure, List<Integer> devine la rulare o listă de obiecte și nu poate conține direct primitive. În C# poți chiar întreba la rulare: typeof(T) sau x is List<int>.

Colecțiile negenerice (ArrayList, Hashtable) nu mai au niciun motiv să fie folosite în cod nou; le întâlnești doar în proiecte vechi. Echivalentele sunt List<T> și Dictionary<TKey, TValue>.

Ce urmărește intervievatorul: O întrebare de bază care verifică înțelegerea motivului, nu doar a sintaxei. Un candidat bun pomenește boxing-ul și diferența față de Java.

Eroarea, în practică:CS0305: generic type requires 1 type arguments

46 Junior

Scrie o metodă generică Maxim<T> care întoarce cel mai mare element dintr-o listă. De ce ai nevoie de o constrângere?

Răspuns scurt: Fără constrângere, compilatorul nu știe cum se compară două valori de tip T, deci nu poți folosi > sau CompareTo. Cu where T : IComparable<T> poți apela CompareTo pe orice T.

Într-o metodă generică, compilatorul permite doar operațiile valabile pentru orice tip T posibil. a > b nu există pentru orice tip, deci trebuie să promiți, printr-o constrângere, că T știe să se compare:

C#
static T Maxim<T>(IReadOnlyList<T> valori) where T : IComparable<T>
{
    if (valori.Count == 0)
        throw new ArgumentException("Lista este goală", nameof(valori));

    T max = valori[0];
    for (int i = 1; i < valori.Count; i++)
        if (valori[i].CompareTo(max) > 0)
            max = valori[i];
    return max;
}

Console.WriteLine(Maxim(new[] { 3, 9, 4 }));            // 9
Console.WriteLine(Maxim(new List<string> { "b", "c" })); // c

Tipul T este dedus din argument (type inference), deci nu scrii Maxim<int>(...). Funcționează cu tablouri și liste pentru că amândouă implementează IReadOnlyList<T>.

Din .NET 7 (C# 11) există generic math: interfețe ca INumber<T> din System.Numerics, care permit operatori aritmetici în cod generic. Așa poți scrie o sumă generică:

C#
static T Suma<T>(IEnumerable<T> valori) where T : INumber<T>
{
    T s = T.Zero;
    foreach (var v in valori) s += v;
    return s;
}

Merită pomenite cazurile limită: lista goală (aici excepție explicită, la fel ca Enumerable.Max) și null pentru tipuri referință, pe care CompareTo le tratează diferit în funcție de tip. În cod real ai folosi valori.Max() din LINQ; întrebarea verifică dacă înțelegi constrângerile, nu dacă reinventezi biblioteca standard.

Ce urmărește intervievatorul: Verifică scrierea de cod generic și înțelegerea constrângerilor. Greșeala tipică este încercarea de a folosi > direct pe T.

Eroarea, în practică:Failed to compare two elements in the arrayCS0311: type cannot be used as type parameter 'T'

47 Junior

Ce se întâmplă pe fiecare linie? Cum citești corect o valoare dintr-un Dictionary?

C#
var stoc = new Dictionary<string, int> { ["mere"] = 10 };
stoc["mere"] = 5;
stoc.Add("mere", 7);
Console.WriteLine(stoc["pere"]);

Răspuns scurt: Indexatorul suprascrie valoarea (mere devine 5), Add aruncă ArgumentException pentru cheie existentă, iar citirea unei chei inexistente cu indexatorul aruncă KeyNotFoundException. Pentru citire sigură folosești TryGetValue.

Dicționarul are operații cu comportament diferit la chei existente sau lipsă:

  • stoc[cheie] = valoare: adaugă sau suprascrie, fără excepție
  • stoc.Add(cheie, valoare): aruncă ArgumentException dacă cheia există; util când un duplicat este o eroare de logică
  • stoc.TryAdd(cheie, valoare): întoarce false dacă cheia există
  • stoc[cheie] la citire: aruncă KeyNotFoundException dacă lipsește
  • stoc.TryGetValue(cheie, out var v): întoarce bool, fără excepție

Varianta corectă de citire:

C#
if (stoc.TryGetValue("pere", out int cantitate))
    Console.WriteLine($"Avem {cantitate}");
else
    Console.WriteLine("Nu avem pere");

int c = stoc.GetValueOrDefault("pere");       // 0 dacă lipsește
int d = stoc.GetValueOrDefault("pere", -1);   // valoare implicită aleasă

Un tipar des întâlnit, dar ineficient:

C#
if (stoc.ContainsKey("mere"))
    Console.WriteLine(stoc["mere"]);  // două căutări în dicționar

TryGetValue face o singură căutare. Diferența este mică pentru un apel, dar contează în bucle.

Alte detalii utile la interviu:

  • comparația cheilor se poate configura: new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase) tratează „Mere” și „mere” ca aceeași cheie
  • ordinea de parcurgere nu este garantată; dacă ai nevoie de chei sortate, folosești SortedDictionary<TKey, TValue>
  • cheia nu poate fi null
  • pentru numărarea frecvențelor, CollectionsMarshal.GetValueRefOrAddDefault (.NET 6) permite actualizarea cu o singură căutare, util în cod sensibil la performanță

Ce urmărește intervievatorul: Verifică dacă știi API-ul de zi cu zi al dicționarului. Greșeala tipică este indexatorul pe chei care pot lipsi sau dubla căutare cu ContainsKey.

Eroarea, în practică:KeyNotFoundException: The given key was not presentArgumentException: same key has already been added

48 Junior

De ce aruncă excepție codul următor? Cum elimini corect elementele pare dintr-o listă?

C#
var numere = new List<int> { 1, 2, 3, 4, 5, 6 };
foreach (var n in numere)
    if (n % 2 == 0)
        numere.Remove(n);

Răspuns scurt: Aruncă InvalidOperationException: colecția a fost modificată în timpul enumerării, iar enumeratorul listei detectează asta. Folosești numere.RemoveAll(n => n % 2 == 0), o buclă for de la coadă spre început sau parcurgi o copie.

List<T> ține un contor intern de versiune, incrementat la fiecare modificare. Enumeratorul folosit de foreach reține versiunea de la început și, la fiecare MoveNext, verifică dacă s-a schimbat. Dacă da, aruncă InvalidOperationException cu mesajul „Collection was modified”. Protecția există pentru că, după o ștergere, indicii elementelor se mută și enumerarea ar sări peste elemente sau ar repeta.

Soluții corecte:

C#
// 1. Cea mai bună pentru List<T>: o singură trecere, O(n)
numere.RemoveAll(n => n % 2 == 0);

// 2. Buclă for de la coadă: ștergerea nu afectează indicii încă neparcurși
for (int i = numere.Count - 1; i >= 0; i--)
    if (numere[i] % 2 == 0)
        numere.RemoveAt(i);

// 3. Construiești o listă nouă (fără să o modifici pe cea veche)
var impare = numere.Where(n => n % 2 != 0).ToList();

// 4. Parcurgi o copie
foreach (var n in numere.ToList())
    if (n % 2 == 0) numere.Remove(n);

Varianta greșită care nu aruncă excepție, dar dă rezultat greșit:

C#
for (int i = 0; i < numere.Count; i++)
    if (numere[i] % 2 == 0)
        numere.RemoveAt(i);   // sare peste elementul care alunecă pe poziția i

Cu valorile { 2, 4, 5 }, după ștergerea lui 2, numărul 4 ajunge pe poziția 0, dar i trece la 1, deci 4 rămâne în listă.

Ca performanță, variantele 2 și 4 sunt O(n²) în cel mai rău caz, pentru că fiecare ștergere mută elementele rămase. RemoveAll compactează lista într-o singură trecere.

Ce urmărește intervievatorul: Este una dintre cele mai frecvente erori la juniori. Intervievatorul vrea să vadă și varianta greșită cu for crescător.

Eroarea, în practică:Collection was modified; enumeration may not execute

49 Junior

Când folosești Queue<T>, Stack<T>, LinkedList<T> sau PriorityQueue<TElement, TPriority>? Scrie o funcție care verifică dacă parantezele dintr-un text sunt echilibrate.

Răspuns scurt: Queue pentru prelucrare în ordinea sosirii (FIFO), Stack pentru ultimul intrat, primul ieșit (LIFO), LinkedList pentru inserări dese în mijloc la un nod cunoscut, PriorityQueue (.NET 6) pentru a scoate mereu elementul cu prioritatea cea mai mică.

Pe scurt, cu exemple tipice:

  • Queue<T> (FIFO): sarcini de procesat în ordinea sosirii, parcurgerea în lățime (BFS) a unui graf; Enqueue, Dequeue, Peek
  • Stack<T> (LIFO): undo/redo, evaluarea expresiilor, parcurgerea în adâncime fără recursivitate, verificarea parantezelor; Push, Pop, Peek
  • LinkedList<T>: inserare și ștergere O(1) când ai deja referința la nod (de exemplu într-un cache LRU, combinată cu un dicționar); acces după index O(n), deci rar folosită altfel
  • PriorityQueue<TElement, TPriority>: algoritmul lui Dijkstra, planificarea sarcinilor după urgență; Dequeue scoate elementul cu prioritatea minimă

Funcția cerută, cu stivă:

C#
static bool Echilibrat(string text)
{
    var stiva = new Stack<char>();
    foreach (char c in text)
    {
        if (c is '(' or '[' or '{')
            stiva.Push(c);
        else if (c is ')' or ']' or '}')
        {
            if (stiva.Count == 0) return false;
            char deschis = stiva.Pop();
            bool potrivit = (deschis, c) is ('(', ')') or ('[', ']') or ('{', '}');
            if (!potrivit) return false;
        }
    }
    return stiva.Count == 0;
}

Console.WriteLine(Echilibrat("{a[b(c)]}")); // True
Console.WriteLine(Echilibrat("(]"));        // False
Console.WriteLine(Echilibrat("(("));        // False

Ideea: fiecare paranteză închisă trebuie să corespundă ultimei paranteze deschise încă neînchise, exact ce oferă o stivă. Complexitatea este O(n). Cele două condiții de eșec importante sunt închiderea fără deschidere (stivă goală) și paranteze rămase deschise la final.

Ce urmărește intervievatorul: Verifică dacă alegi structura potrivită pentru problemă. Exercițiul cu paranteze apare des la interviuri de cod live.

50 Junior

Care este diferența dintre int[,] și int[][]? Ce afișează codul?

C#
int[,] matrice = new int[3, 4];
int[][] zimtat = new int[3][];
zimtat[0] = new int[] { 1, 2 };
zimtat[1] = new int[5];

Console.WriteLine(matrice.Length);
Console.WriteLine(matrice.GetLength(1));
Console.WriteLine(zimtat.Length);
Console.WriteLine(zimtat[2] == null);

Răspuns scurt: Afișează 12, 4, 3 și True. int[,] este un tablou dreptunghiular (multidimensional), un singur bloc de memorie; int[][] este un tablou de tablouri (jagged), unde fiecare rând este un obiect separat și poate avea altă lungime.

Tabloul multidimensional int[3, 4] are exact 3 rânduri și 4 coloane, alocate într-un singur bloc. Length întoarce numărul total de elemente (12), iar GetLength(dimensiune) lungimea pe o dimensiune: GetLength(0) este 3, GetLength(1) este 4. Accesul se face cu matrice[1, 2].

Tabloul zimțat (jagged) int[3][] este un tablou cu 3 elemente, fiecare fiind o referință la un int[]. La creare, aceste referințe sunt null; fiecare rând trebuie creat separat și poate avea orice lungime. zimtat.Length este 3 (numărul de rânduri), iar zimtat[2] nu a fost creat, deci este null. Accesul se face cu zimtat[0][1].

Parcurgerea corectă a fiecăruia:

C#
for (int i = 0; i < matrice.GetLength(0); i++)
    for (int j = 0; j < matrice.GetLength(1); j++)
        matrice[i, j] = i * j;

foreach (int[]? rand in zimtat)
{
    if (rand is null) continue;
    Console.WriteLine(string.Join(" ", rand));
}

Când alegi:

  • int[,] pentru grile fixe și dreptunghiulare (tabla de X și 0, o imagine); codul este clar, nu poți avea rânduri lipsă
  • int[][] pentru rânduri de lungimi diferite (triunghiul lui Pascal, liste de adiacență) sau când vrei să schimbi un rând întreg dintr-o atribuire

Un detaliu de performanță: JIT-ul optimizează mai bine tablourile unidimensionale, deci accesul într-un jagged array este adesea mai rapid decât în int[,], în ciuda alocărilor multiple. Pentru performanță maximă, unele coduri folosesc un singur int[] de mărime rânduri × coloane, cu indexul i * coloane + j.

Ambele sunt de mărime fixă; dacă ai nevoie să adaugi rânduri, folosești List<int[]> sau List<List<int>>.

Ce urmărește intervievatorul: Verifică dacă știi structura de memorie a celor două tipuri de tablouri. Greșeala tipică este presupunerea că rândurile jagged sunt create automat.

51 Mid

Ce afișează codul următor? Ce costă operațiile Add, Insert(0, x) și Contains pe un List<T>?

C#
var lista = new List<int>();
Console.WriteLine(lista.Capacity);
lista.Add(1);
Console.WriteLine(lista.Capacity);
for (int i = 0; i < 4; i++) lista.Add(i);
Console.WriteLine($"{lista.Count} {lista.Capacity}");

Răspuns scurt: Afișează 0, 4 și „5 8”. List<T> are în spate un tablou care se dublează când se umple. Add este O(1) amortizat, Insert(0, x) este O(n), pentru că mută toate elementele, iar Contains este O(n).

List<T> stochează elementele într-un tablou intern. Count este numărul de elemente folosite, iar Capacity mărimea tabloului. O listă nouă pornește cu un tablou gol; la primul Add se alocă un tablou de 4 elemente. Când se umple, se alocă unul de mărime dublă, se copiază elementele vechi, iar tabloul vechi rămâne pentru garbage collector.

De aici costurile:

  • Add: de obicei O(1); ocazional O(n) la redimensionare, dar pentru că mărimea se dublează, costul mediu (amortizat) rămâne O(1)
  • indexarea lista[i]: O(1)
  • Insert(0, x) și RemoveAt(0): O(n), pentru că toate elementele se mută cu o poziție
  • Contains, IndexOf, Remove(x): O(n), căutare liniară
  • Sort: O(n log n)

Consecințe practice:

C#
var rezultate = new List<Rand>(randuri.Count);  // știi mărimea: eviți redimensionările
  • dacă știi numărul aproximativ de elemente, dă capacitatea din constructor; eviți mai multe alocări și copieri
  • dacă inserezi sau scoți des de la început, Queue<T> sau LinkedList<T> sunt potrivite
  • dacă verifici des Contains, un HashSet<T> face asta în O(1) în medie
  • TrimExcess() reduce capacitatea după ce ai terminat de adăugat, dacă lista trăiește mult

Valorile exacte ale capacității sunt detalii de implementare (4 și dublarea sunt comportamentul din .NET actual), iar intervievatorul nu așteaptă să le memorezi. Important este modelul: un tablou dinamic, cu cost amortizat la adăugare și cost liniar la inserarea în față.

Ce urmărește intervievatorul: Verifică dacă înțelegi structura de date din spatele celei mai folosite colecții. Un candidat mid poate justifica alegerea colecției prin complexitate.

52 Mid

Codul următor elimină duplicatele dintr-o listă de un milion de numere și este foarte lent. De ce și cum îl rescrii?

C#
var unice = new List<int>();
foreach (var x in date)
    if (!unice.Contains(x))
        unice.Add(x);

Răspuns scurt: List.Contains este O(n), iar apelat pentru fiecare element dă O(n²). Cu un HashSet<int>, verificarea și adăugarea sunt O(1) în medie, deci tot algoritmul devine O(n).

Pentru fiecare element din date, unice.Contains(x) parcurge toată lista de elemente unice găsite până atunci. Dacă majoritatea numerelor sunt distincte, numărul de comparații crește aproximativ cu pătratul numărului de elemente. Pentru un milion de elemente vorbim de ordinul a sute de miliarde de comparații, deci minute în loc de milisecunde.

Rescrierea:

C#
// păstrează ordinea primei apariții
var vazute = new HashSet<int>();
var unice = new List<int>();
foreach (var x in date)
    if (vazute.Add(x))        // Add întoarce false dacă elementul exista deja
        unice.Add(x);

// variante echivalente, mai scurte
var unice2 = date.Distinct().ToList();      // folosește intern un set, păstrează ordinea
var set = new HashSet<int>(date);           // dacă ordinea nu contează

HashSet<T>.Add combină verificarea și adăugarea într-o singură căutare.

Tabelul de complexitate pe care merită să-l știi:

  • List<T>: index O(1), Contains O(n), Add O(1) amortizat
  • HashSet<T> / Dictionary<TKey, TValue>: căutare, adăugare, ștergere O(1) în medie (O(n) în cel mai rău caz, cu multe coliziuni de hash)
  • SortedSet<T> / SortedDictionary<TKey, TValue>: O(log n), arbore roșu-negru, elemente mereu sortate
  • SortedList<TKey, TValue>: căutare O(log n), inserare O(n), dar memorie compactă
  • LinkedList<T>: inserare O(1) la un nod cunoscut, căutare O(n)

Prețul unui set: mai multă memorie decât o listă și necesitatea unui GetHashCode bun pentru tipurile proprii. Pentru câteva zeci de elemente, diferența nu contează și lista poate fi chiar mai rapidă. Pentru colecții mari, alegerea structurii de date contează mai mult decât orice micro-optimizare.

Ce urmărește intervievatorul: Verifică dacă recunoști un algoritm pătratic ascuns. Este o problemă reală frecventă, nu doar teoretică.

53 Mid

Care este diferența dintre IReadOnlyList<T>, ReadOnlyCollection<T>, ImmutableList<T> și FrozenDictionary<TKey, TValue>?

Răspuns scurt: IReadOnlyList<T> este doar o interfață fără metode de modificare; ReadOnlyCollection<T> este un wrapper peste o listă care se poate schimba dedesubt; colecțiile imutabile nu se schimbă niciodată și întorc copii la modificare; colecțiile frozen (.NET 8) sunt optimizate pentru citiri, după o construcție costisitoare.

Diferența este între „nu poți modifica prin această referință” și „nimeni nu poate modifica”.

C#
var lista = new List<int> { 1, 2, 3 };

IReadOnlyList<int> vedere = lista;                // aceeași listă, altă interfață
ReadOnlyCollection<int> wrapper = lista.AsReadOnly();
ImmutableList<int> imutabila = lista.ToImmutableList();

lista.Add(4);
Console.WriteLine(vedere.Count);     // 4
Console.WriteLine(wrapper.Count);    // 4: vede modificarea listei originale
Console.WriteLine(imutabila.Count);  // 3: copie independentă

var noua = imutabila.Add(5);         // întoarce o listă nouă
Console.WriteLine(imutabila.Count);  // tot 3
  • IReadOnlyList<T> / IReadOnlyCollection<T> / IReadOnlyDictionary<TKey, TValue>: contracte care spun apelantului „doar citești”. Obiectul real poate fi o List<T> pe care cineva o poate obține printr-un cast. Potrivit pentru tipurile de retur din cod intern
  • ReadOnlyCollection<T>: un obiect separat, care nu poate fi convertit înapoi la listă; protejează împotriva apelanților, dar reflectă modificările făcute de proprietarul listei
  • ImmutableList<T>, ImmutableArray<T>, ImmutableDictionary<TKey, TValue> (System.Collections.Immutable): garanție totală, sigure între fire de execuție fără lock-uri. „Modificarea” creează o colecție nouă, cu partajarea structurii interne (la ImmutableList, un arbore), deci citirile sunt mai lente decât la List<T>. ImmutableArray<T> are citiri rapide, dar fiecare modificare copiază tot
  • FrozenSet<T> și FrozenDictionary<TKey, TValue> (.NET 8, System.Collections.Frozen): construite o dată cu ToFrozenDictionary(), analizează datele ca să aleagă o strategie de căutare rapidă. Potrivite pentru date citite foarte des și construite rar: tabele de configurare, liste de coduri

Alegerea ține de cine trebuie protejat de ce: apelantul de propriile greșeli (interfață), proprietarul datelor de apelanți (wrapper) sau toată lumea, inclusiv alte fire (imutabil).

Ce urmărește intervievatorul: Verifică înțelegerea nuanțelor dintre „doar citire” și „imutabil”. Mulți candidați cred că IReadOnlyList garantează că datele nu se schimbă.

54 Mid

Implementează o stivă generică Stiva<T> cu Push, Pop și Peek, fără să folosești Stack<T>.

Răspuns scurt: Folosești un tablou intern și un contor: Push scrie la poziția Count și dublează tabloul când e plin, Pop scade contorul și întoarce elementul. Golești poziția eliberată, ca obiectul să poată fi colectat de garbage collector.

O implementare completă, cu explicațiile pe care le-ai da la tablă:

C#
public class Stiva<T>
{
    private T[] _elemente = new T[4];
    private int _count;

    public int Count => _count;

    public void Push(T element)
    {
        if (_count == _elemente.Length)
            Array.Resize(ref _elemente, _elemente.Length * 2);
        _elemente[_count++] = element;
    }

    public T Pop()
    {
        if (_count == 0)
            throw new InvalidOperationException("Stiva este goală");
        T element = _elemente[--_count];
        _elemente[_count] = default!;     // eliberăm referința
        return element;
    }

    public T Peek() =>
        _count == 0
            ? throw new InvalidOperationException("Stiva este goală")
            : _elemente[_count - 1];

    public bool TryPop(out T element)
    {
        if (_count == 0) { element = default!; return false; }
        element = Pop();
        return true;
    }
}

Deciziile de design:

  • dublarea capacității face ca Push să fie O(1) amortizat; o creștere cu câte un element ar face fiecare Push O(n)
  • golirea poziției după Pop: dacă T este un tip referință, tabloul ar păstra altfel o referință la obiect, iar acesta nu ar putea fi colectat până la suprascriere; este o scurgere de memorie subtilă. Biblioteca standard face la fel (doar pentru tipurile care conțin referințe)
  • excepție la stivă goală, ca Stack<T>, plus varianta TryPop pentru cazurile în care stiva goală este normală
  • default! spune compilatorului că știm că valoarea poate fi null pentru tipuri referință

Extensii pe care intervievatorul le poate cere: implementarea IEnumerable<T> (parcurgere de la vârf spre bază, cu yield return), detectarea modificării în timpul enumerării cu un contor de versiune, sau o variantă imutabilă bazată pe noduri înlănțuite, unde Push întoarce o stivă nouă.

Ce urmărește intervievatorul: Este un exercițiu de cod care verifică tablourile, genericele și atenția la memorie. Detaliul cu golirea poziției distinge un candidat mid.

Eroarea, în practică:InvalidOperationException: Stack empty.

55 Senior

Ce afișează codul următor? Ce înseamnă un câmp static într-o clasă generică?

C#
class Cache<T>
{
    public static int Accesari;
}

Cache<int>.Accesari++;
Cache<int>.Accesari++;
Cache<string>.Accesari++;
Console.WriteLine(Cache<int>.Accesari);
Console.WriteLine(Cache<string>.Accesari);

Răspuns scurt: Afișează 2 și 1. Fiecare tip generic închis (Cache<int>, Cache<string>) este un tip separat la rulare, cu propriile câmpuri statice și propriul constructor static.

Cache<T> este o definiție de tip deschis. La rulare, Cache<int> și Cache<string> sunt tipuri distincte, iar fiecare are propriul set de câmpuri statice. De aceea contoarele sunt separate. La fel, un constructor static rulează o dată pentru fiecare tip închis folosit.

Acest comportament stă la baza unui tipar util, cache-ul static generic, folosit intens chiar în biblioteca standard:

C#
static class InfoTip<T>
{
    public static readonly string Nume = typeof(T).Name;
    public static readonly bool EsteValoare = typeof(T).IsValueType;
}

Console.WriteLine(InfoTip<DateTime>.Nume);   // DateTime, calculat o singură dată

EqualityComparer<T>.Default, Comparer<T>.Default și Array.Empty<T>() funcționează așa: valoarea se calculează la prima utilizare pentru fiecare T și apoi e citită ca un câmp obișnuit, fără dicționar și fără lock. Este mai rapid decât un Dictionary<Type, ...>.

Detalii pe care un senior le cunoaște:

  • pentru tipuri referință, JIT-ul partajează codul mașină între Cache<string> și Cache<object>, dar câmpurile statice rămân separate
  • un câmp static într-un tip generic este adesea o greșeală când autorul voia o valoare comună pentru toate T; analizorul CA1000 descurajează membrii statici pe tipuri generice publice, iar soluția este o clasă negenerică separată pentru starea comună
  • fiecare T nou înseamnă un tip nou încărcat în memorie; dacă T este generat dinamic (de exemplu prin reflecție, cu multe combinații), pot apărea consumuri neașteptate de memorie
  • inițializarea statică este thread-safe garantat de runtime: constructorul static rulează o singură dată, chiar dacă mai multe fire accesează tipul simultan

Ce urmărește intervievatorul: Testează înțelegerea modelului de tipuri generice la rulare. Un senior recunoaște și tiparul cache-ului static generic din biblioteca standard.

56 Senior

Ce problemă are codul următor într-un serviciu folosit de mai multe fire de execuție și cum o rezolvi?

C#
private static readonly ConcurrentDictionary<string, Raport> _cache = new();

public Raport Obtine(string cheie) =>
    _cache.GetOrAdd(cheie, k => GenereazaRaportCostisitor(k));

Răspuns scurt: GetOrAdd este atomic doar pentru adăugare: dacă mai multe fire cer simultan aceeași cheie, fabrica poate rula de mai multe ori, deși se păstrează o singură valoare. Pentru operații costisitoare sau cu efecte secundare stochezi Lazy<Raport>.

ConcurrentDictionary garantează că structura internă nu se corupe și că pentru o cheie se păstrează o singură valoare. Nu garantează însă că delegatul din GetOrAdd rulează o singură dată. Fabrica se execută în afara lock-urilor interne, ca să nu blocheze alte operații. Dacă trei cereri pentru aceeași cheie sosesc simultan, toate trei pot apela GenereazaRaportCostisitor; una câștigă, iar celelalte două rezultate sunt aruncate. Dacă generarea durează secunde sau trimite un email, ai o problemă.

Soluția standard este să stochezi o valoare leneșă:

C#
private static readonly ConcurrentDictionary<string, Lazy<Raport>> _cache = new();

public Raport Obtine(string cheie) =>
    _cache.GetOrAdd(cheie, k => new Lazy<Raport>(() => GenereazaRaportCostisitor(k))).Value;

Pot fi create mai multe obiecte Lazy (ieftine), dar doar unul ajunge în dicționar, iar toate firele citesc .Value din același obiect. Modul implicit LazyThreadSafetyMode.ExecutionAndPublication garantează că fabrica rulează o singură dată. Atenție: dacă fabrica aruncă o excepție, Lazy o memorează și o va arunca la fiecare acces, deci uneori vrei să elimini intrarea din cache în caz de eroare.

Alte capcane frecvente cu colecțiile concurente:

  • operații compuse ne-atomice: if (!d.ContainsKey(k)) d[k] = v; are o fereastră de cursă; folosești TryAdd, AddOrUpdate sau TryUpdate
  • Count, Keys și enumerarea iau o imagine de moment, nu blochează colecția
  • un Dictionary<TKey, TValue> obișnuit modificat din mai multe fire nu doar dă rezultate greșite, ci își poate corupe structura internă

Pentru un cache real, cu expirare și limită de memorie, MemoryCache sau HybridCache (.NET 9) rezolvă și protecția împotriva cererilor simultane pentru aceeași cheie.

Ce urmărește intervievatorul: Verifică înțelegerea exactă a garanțiilor colecțiilor concurente. Puțini candidați știu că fabrica poate rula de mai multe ori.

Delegați, lambda și evenimente

Exersează capitolul cu exerciții reale: Curs C# →
57 Junior

Scrie o metodă Filtreaza care primește un tablou de numere și o condiție, și întoarce numerele care respectă condiția. Apeleaz-o cu o lambda și cu o metodă existentă.

Răspuns scurt: Condiția se transmite ca parametru de tip Func<int, bool>: o funcție care primește un int și întoarce bool. La apel poți da o lambda (n => n % 2 == 0) sau numele unei metode cu aceeași semnătură.

Ideea este să transmiți comportament ca parametru, nu doar date:

C#
static List<int> Filtreaza(int[] numere, Func<int, bool> conditie)
{
    var rezultat = new List<int>();
    foreach (int n in numere)
        if (conditie(n))
            rezultat.Add(n);
    return rezultat;
}

static bool EsteMare(int n) => n > 10;

var pare = Filtreaza(new[] { 1, 2, 3, 4 }, n => n % 2 == 0);   // lambda
var mari = Filtreaza(new[] { 5, 50, 500 }, EsteMare);           // method group
int prag = 3;
var pestePrag = Filtreaza(new[] { 1, 5, 9 }, n => n > prag);    // lambda care capturează prag

Console.WriteLine(string.Join(", ", pare));       // 2, 4
Console.WriteLine(string.Join(", ", pestePrag));  // 5, 9

Func<int, bool> este un tip delegat predefinit: ultimul parametru generic este tipul de retur, cei dinainte sunt tipurile parametrilor. Familia completă:

  • Func<T1, ..., TResult>: întoarce o valoare
  • Action<T1, ...>: nu întoarce nimic
  • Predicate<T>: echivalent cu Func<T, bool>, folosit de metode mai vechi precum List<T>.FindAll

Un detaliu: Predicate<int> și Func<int, bool> au aceeași semnătură, dar sunt tipuri diferite; nu poți atribui un Predicate<int> unei variabile Func<int, bool> fără conversie. O lambda, în schimb, se convertește la oricare dintre ele.

Așa funcționează și LINQ: Where este, în esență, Filtreaza scris generic, ca metodă de extensie pe IEnumerable<T>, cu evaluare amânată. Exercițiul este un bun punct de plecare pentru a explica de ce LINQ arată așa cum arată.

Ce urmărește intervievatorul: Verifică dacă poți transmite funcții ca parametri și dacă înțelegi Func. Este baza pentru LINQ și pentru orice API cu callback-uri.

58 Junior

Ce forme poate avea o expresie lambda în C#? Explică fiecare linie.

C#
Func<int, int> dublu = x => x * 2;
Func<int, int, int> suma = (a, b) => a + b;
Action salut = () => Console.WriteLine("Salut");
Func<int, int, int> primul = (a, _) => a;
Func<int, int> sigur = static x => x + 1;
var incrementeaza = (int x, int pas = 1) => x + pas;

Răspuns scurt: Lambda are parametrii în stânga lui => și corpul în dreapta: o expresie sau un bloc între acolade. C# modern adaugă discard-uri pentru parametri neutilizați, lambda static care nu poate captura variabile și, din C# 12, parametri cu valori implicite.

Linie cu linie:

  • x => x * 2: un parametru, fără paranteze, corp de tip expresie; tipul lui x este dedus din Func<int, int>
  • (a, b) => a + b: mai mulți parametri cer paranteze
  • () => Console.WriteLine("Salut"): fără parametri, convertit la Action
  • (a, _) => a: _ este un discard (C# 9) pentru un parametru pe care nu îl folosești; util la evenimente, unde semnătura e impusă
  • static x => x + 1: lambda statică (C# 9) nu poate captura variabile locale sau this; compilatorul refuză dacă încerci. Garantează că nu se alocă un obiect pentru closure
  • (int x, int pas = 1) => x + pas: tipuri explicite și parametru cu valoare implicită (C# 12); tipul delegatului este generat de compilator, de aceea se folosește var

Corpul poate fi și un bloc de instrucțiuni:

C#
Func<string, int> numaraVocale = text =>
{
    int n = 0;
    foreach (char c in text.ToLower())
        if ("aeiouăâî".Contains(c)) n++;
    return n;
};

Când corpul este un bloc, ai nevoie de return explicit pentru valori.

Câteva sfaturi de stil pe care merită să le pomenești:

  • lambda-urile scurte sunt potrivite în LINQ și pentru callback-uri; dacă depășesc câteva linii, o metodă cu nume este mai ușor de citit, testat și depanat
  • poți avea și lambda async: Func<Task> f = async () => await Task.Delay(10);
  • atributele se pot pune pe lambda din C# 10: [Obsolete] () => 1, util în minimal APIs

Ce urmărește intervievatorul: Verifică familiaritatea cu sintaxa, inclusiv cu adăugirile recente. Candidații juniori cunosc de obicei doar primele trei forme.

Eroarea, în practică:CS8917: The delegate type could not be inferredCS1593: Delegate does not take N arguments

59 Junior

Cum declari și declanșezi un eveniment în C# folosind EventHandler<T>? Arată un exemplu cu un depozit care anunță când stocul unui produs s-a epuizat.

Răspuns scurt: Declari public event EventHandler<StocEpuizatEventArgs>? StocEpuizat;, îl declanșezi dintr-o metodă protejată cu StocEpuizat?.Invoke(this, args), iar abonații se înscriu cu += și se dezabonează cu -=.

Convenția .NET pentru evenimente are trei părți: o clasă de argumente, evenimentul și o metodă care îl declanșează.

C#
public class StocEpuizatEventArgs : EventArgs
{
    public string Produs { get; }
    public StocEpuizatEventArgs(string produs) => Produs = produs;
}

public class Depozit
{
    private readonly Dictionary<string, int> _stoc = new() { ["mere"] = 2 };

    public event EventHandler<StocEpuizatEventArgs>? StocEpuizat;

    public void Scoate(string produs, int cantitate)
    {
        _stoc[produs] = _stoc.GetValueOrDefault(produs) - cantitate;
        if (_stoc[produs] <= 0)
            OnStocEpuizat(new StocEpuizatEventArgs(produs));
    }

    protected virtual void OnStocEpuizat(StocEpuizatEventArgs e) =>
        StocEpuizat?.Invoke(this, e);
}

var depozit = new Depozit();
depozit.StocEpuizat += (sender, e) => Console.WriteLine($"Comandă nouă pentru {e.Produs}");
depozit.Scoate("mere", 2);   // Comandă nouă pentru mere

De ce fiecare element:

  • semnătura (object? sender, TEventArgs e) este standard, așa că orice abonat știe cine a trimis evenimentul și ce date are
  • ?.Invoke evită NullReferenceException când nu există abonați și citește delegatul o singură dată, deci e sigur și dacă un alt fir se dezabonează între verificare și apel
  • protected virtual OnXxx permite claselor derivate să intercepteze sau să declanșeze evenimentul
  • event (nu un câmp delegat public) împiedică exteriorul să declanșeze evenimentul sau să șteargă abonații

Dezabonarea are o capcană: depozit.StocEpuizat -= (s, e) => ... cu o lambda nouă nu elimină nimic, pentru că este altă instanță. Dacă vrei să te dezabonezi, păstrezi handler-ul într-o variabilă sau folosești o metodă cu nume. Iar un abonat cu durată scurtă de viață care nu se dezabonează rămâne referit de sursa evenimentului și nu poate fi colectat.

Ce urmărește intervievatorul: Verifică dacă știi convenția standard și de ce există. Detaliile cu ?.Invoke și dezabonarea lambda-urilor arată experiență practică.

60 Junior

Care dintre liniile următoare compilează în C# 10 sau mai nou și de ce?

C#
var dublu = (int x) => x * 2;
var salut = () => Console.WriteLine("salut");
Func<string, int> conversie = int.Parse;
var parsare = int.Parse;
var identitate = x => x;

Răspuns scurt: Primele trei compilează: lambda cu tipuri explicite are un tip natural (C# 10), iar un method group se poate atribui unui tip delegat explicit. Ultimele două nu: int.Parse are mai multe supraîncărcări, iar x => x nu are tipul parametrului.

Înainte de C# 10, o lambda nu putea fi atribuită lui var, pentru că nu avea tip propriu: aceeași lambda putea deveni Func<int, int>, un delegat personalizat sau un Expression<Func<int, int>>. C# 10 a introdus tipul natural al lambda-urilor și al method group-urilor: când compilatorul poate deduce toate tipurile, alege un Func<...> sau Action<...> potrivit.

Linie cu linie:

  • var dublu = (int x) => x * 2;: tipul parametrului e explicit, iar tipul de retur e dedus: Func<int, int>
  • var salut = () => Console.WriteLine("salut");: Action
  • Func<string, int> conversie = int.Parse;: un method group (numele unei metode fără apel) se convertește la un delegat cu semnătură compatibilă; compilatorul alege supraîncărcarea Parse(string) după tipul țintă
  • var parsare = int.Parse;: eroare, pentru că int.Parse are mai multe supraîncărcări (string, ReadOnlySpan<char>, cu stiluri și culturi) și nu există tip țintă care să decidă
  • var identitate = x => x;: eroare, nu se poate deduce tipul lui x

Ce poți face în schimb:

C#
var lungime = (string s) => s.Length;     // Func<string, int>
var citeste = Console.ReadLine;           // merge: o singură supraîncărcare
Func<int, int> id = x => x;               // tip țintă explicit

Utilitatea practică a tipului natural se vede cel mai clar în ASP.NET Core minimal APIs, unde app.MapGet("/", () => "Salut") primește un Delegate, iar framework-ul inspectează parametrii lambda-ului. Și în cod obișnuit, var cu lambda face mai ușoară scrierea funcțiilor locale scurte.

Ce urmărește intervievatorul: Verifică înțelegerea legăturii dintre lambda, method group și tipurile delegat. Linia cu int.Parse arată dacă știi de ce o conversie poate eșua.

Eroarea, în practică:CS0428: Cannot convert method groupCS8917: The delegate type could not be inferred

61 Mid

Ce afișează codul următor și cum îl repari?

C#
var actiuni = new List<Action>();
for (int i = 0; i < 3; i++)
    actiuni.Add(() => Console.Write(i + " "));

foreach (var a in actiuni)
    a();

Răspuns scurt: Afișează „3 3 3”. Lambda capturează variabila i, nu valoarea ei din momentul creării, iar în bucla for există o singură variabilă i, care la final are valoarea 3. Repari copiind valoarea într-o variabilă locală din corpul buclei.

Când o lambda folosește o variabilă locală din exterior, compilatorul creează un closure: mută variabila într-un obiect ascuns (o „display class”), iar lambda păstrează o referință la acel obiect. Toate lambda-urile care folosesc aceeași variabilă văd aceeași locație de memorie, nu o copie.

Într-un for, variabila i este declarată o singură dată, înainte de buclă. Toate cele trei lambda-uri referă același i. Când sunt apelate, bucla s-a terminat, iar i a ajuns la 3, valoarea care a oprit condiția i < 3.

Reparația este o variabilă nouă la fiecare iterație:

C#
for (int i = 0; i < 3; i++)
{
    int copie = i;                       // o variabilă nouă la fiecare pas
    actiuni.Add(() => Console.Write(copie + " "));
}
// 0 1 2

foreach se comportă diferit din C# 5: variabila de iterație este considerată declarată în interiorul buclei, deci fiecare iterație are propria variabilă:

C#
foreach (var n in new[] { 0, 1, 2 })
    actiuni.Add(() => Console.Write(n + " "));  // 0 1 2

Schimbarea din C# 5 a fost o modificare care a rupt compatibilitatea, făcută tocmai pentru că bug-ul era foarte frecvent. La for comportamentul a rămas, pentru că acolo variabila este modificată explicit de i++.

Aceeași capcană apare în cod real cu Task.Run(() => Proceseaza(i)) într-un for, cu handler-e de evenimente create în buclă și cu interogări LINQ care capturează o variabilă modificată ulterior. Mai e un cost ascuns: fiecare closure alocă un obiect, iar lambda-urile static (C# 9) îți garantează că nu capturezi nimic accidental.

Ce urmărește intervievatorul: Este un clasic care verifică înțelegerea closure-urilor. Un candidat bun explică și diferența dintre for și foreach.

62 Mid

Care este diferența dintre un câmp delegat public și un eveniment? Ce linii nu compilează?

C#
public class Buton
{
    public Action? Click;
    public event Action? Apasat;
}

var b = new Buton();
b.Click = null;
b.Click?.Invoke();
b.Apasat += () => Console.WriteLine("apăsat");
b.Apasat = null;
b.Apasat?.Invoke();

Răspuns scurt: Ultimele două linii nu compilează (eroarea CS0070). Cuvântul cheie event restricționează accesul din exterior la += și -=: doar clasa care declară evenimentul îl poate declanșa sau reseta. Un câmp delegat public poate fi suprascris și apelat de oricine.

Un eveniment este un delegat împachetat cu reguli de acces, similar cu felul în care o proprietate împachetează un câmp. Din afara clasei:

  • câmpul public Click poate fi atribuit (b.Click = handler, care șterge toți abonații existenți), resetat la null și invocat de orice cod
  • evenimentul Apasat permite doar abonare (+=) și dezabonare (-=)

De ce contează:

  • un abonat care scrie din greșeală b.Click = handlerulMeu în loc de += îi elimină pe toți ceilalți, fără nicio eroare
  • un cod din exterior poate declanșa Click fără ca butonul să fi fost apăsat, ceea ce încalcă încapsularea: doar sursa ar trebui să decidă când are loc evenimentul

În interiorul clasei, Apasat se comportă ca un câmp delegat obișnuit, deci clasa îl poate invoca și reseta.

Compilatorul generează pentru un eveniment declarat ca mai sus metodele add_Apasat și remove_Apasat, care modifică delegatul în mod thread-safe. Poți scrie și accesorii manual, de exemplu ca să redirecționezi abonarea spre alt obiect sau ca să păstrezi abonații altfel:

C#
private readonly List<Action> _abonati = new();
public event Action Schimbat
{
    add => _abonati.Add(value);
    remove => _abonati.Remove(value);
}

Regula de design: folosești event când clasa anunță ceva ce s-a întâmplat și pot exista mai mulți ascultători. Folosești un parametru sau o proprietate de tip Func/Action când ai nevoie de un singur callback configurabil, de exemplu o strategie de calcul transmisă în constructor.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce adaugă cuvântul cheie event peste un delegat. Mulți candidați cred că sunt doar sinonime.

Eroarea, în practică:CS0070: event only on the left of += or -=

63 Mid

Care este diferența dintre o funcție locală și o lambda? Când ai prefera una dintre ele?

Răspuns scurt: Funcția locală este o metodă propriu-zisă: poate fi recursivă, generică, apelată înainte de declarare și nu alocă un delegat dacă nu o convertești. Lambda este o valoare de tip delegat, potrivită ca argument.

O funcție locală (C# 7) este o metodă declarată în corpul altei metode:

C#
static long Factorial(int n)
{
    if (n < 0) throw new ArgumentOutOfRangeException(nameof(n));
    return Calculeaza(n);

    static long Calculeaza(int k) => k <= 1 ? 1 : k * Calculeaza(k - 1);
}

Avantaje față de lambda:

  • recursivitatea este naturală; o lambda recursivă cere o declarare separată a variabilei înainte de atribuire
  • poate fi generică (T Primul<T>(...)) și poate avea parametri ref, out, params
  • poate fi apelată înainte de locul în care e scrisă
  • dacă nu o transformi în delegat, nu se alocă nimic; chiar și variabilele capturate sunt ținute într-un struct pe stivă, nu într-un obiect pe heap
  • cu static (C# 8) garantezi că nu capturează nimic

Un tipar clasic în care funcția locală rezolvă o problemă reală este validarea argumentelor la iteratori:

C#
public static IEnumerable<int> Interval(int start, int numar)
{
    if (numar < 0) throw new ArgumentOutOfRangeException(nameof(numar)); // rulează imediat
    return Genereaza();

    IEnumerable<int> Genereaza()
    {
        for (int i = 0; i < numar; i++) yield return start + i;
    }
}

Dacă yield return ar fi fost direct în Interval, validarea ar fi rulat abia la prima enumerare, departe de locul apelului greșit.

Lambda rămâne alegerea firească atunci când logica este un argument: lista.Where(x => x.Activ), un handler de eveniment, o strategie transmisă. Regula practică: lambda pentru o expresie scurtă trimisă undeva, funcție locală pentru o bucată de logică ajutătoare cu nume, folosită doar de metoda curentă.

Ce urmărește intervievatorul: Verifică înțelegerea diferențelor practice, nu doar sintactice. Exemplul cu iteratorul arată dacă știi un caz real de utilizare.

Eroarea, în practică:CS8421: static local function cannot reference

64 Senior

Ce afișează codul următor? Ce se întâmplă dacă unul dintre delegații din lanț aruncă o excepție?

C#
Func<int> f = () => 1;
f += () => 2;
f += () => 3;
Console.WriteLine(f());
Console.WriteLine(f.GetInvocationList().Length);

Răspuns scurt: Afișează 3 și 3. Un delegat multicast apelează toate metodele din listă, în ordine, dar întoarce doar valoarea ultimei. Dacă una aruncă excepție, apelurile următoare nu mai au loc, iar excepția ajunge la cel care a invocat delegatul.

Orice delegat în .NET este multicast: poate conține o listă de metode. += creează un delegat nou, cu lista extinsă (delegații sunt imutabili, deci originalul nu se modifică). La invocare, metodele se apelează în ordinea adăugării. Valorile de retur ale tuturor, cu excepția ultimei, se pierd. De aceea delegații multicast se folosesc aproape exclusiv cu tip de retur void, cum sunt evenimentele.

Dacă ai nevoie de toate rezultatele, le obții explicit:

C#
foreach (Func<int> d in f.GetInvocationList().Cast<Func<int>>())
    Console.Write(d() + " ");   // 1 2 3

Problema excepțiilor este mai importantă în practică. Invocarea unui eveniment cu trei abonați este, în esență, un foreach fără try. Dacă al doilea abonat aruncă excepție, al treilea nu este notificat, iar codul care a declanșat evenimentul primește o excepție din codul altcuiva. Într-un sistem cu pluginuri sau cu module independente, un abonat defect îi poate afecta pe toți.

Când contează izolarea, invoci separat fiecare abonat:

C#
protected virtual void OnComandaPlasata(ComandaEventArgs e)
{
    if (ComandaPlasata is not { } handler) return;
    foreach (EventHandler<ComandaEventArgs> h in handler.GetInvocationList().Cast<EventHandler<ComandaEventArgs>>())
    {
        try { h(this, e); }
        catch (Exception ex) { _log.LogError(ex, "Abonatul {Abonat} a eșuat", h.Method.Name); }
    }
}

Alte detalii: -= elimină ultima apariție a unei metode, iar dacă lista devine goală delegatul este null. Cu handler-e async void (comune la evenimente), excepțiile nici nu ajung la cel care declanșează, ci direct în contextul de sincronizare, unde pot opri procesul.

Ce urmărește intervievatorul: Verifică înțelegerea modelului multicast și a consecințelor pentru robustețe. Un senior știe cum să izoleze abonații între ei.

65 Senior

Care este diferența dintre Func<int, bool> și Expression<Func<int, bool>>? Ce afișează codul?

C#
Func<int, bool> f = x => x > 5;
Expression<Func<int, bool>> e = x => x > 5;

Console.WriteLine(f(10));
Console.WriteLine(e);
Console.WriteLine(e.Compile()(10));

Răspuns scurt: Afișează True, „x => (x > 5)” și True. Aceeași lambda devine cod executabil când e atribuită unui Func, dar devine un arbore de expresie (o structură de date care descrie codul) când e atribuită unui Expression<Func<...>>.

Compilatorul tratează o lambda în funcție de tipul țintă:

  • pentru Func<int, bool> generează o metodă IL și un delegat către ea; poți doar să o apelezi
  • pentru Expression<Func<int, bool>> generează cod care construiește la rulare un arbore de expresie: obiecte care descriu operația (un BinaryExpression de tip GreaterThan, cu un ParameterExpression și o ConstantExpression)

Arborele poate fi inspectat, transformat sau tradus în altceva. ToString() îl afișează ca text, iar Compile() îl transformă în delegat executabil (operație costisitoare, de evitat în bucle).

C#
var corp = (BinaryExpression)e.Body;
Console.WriteLine(corp.NodeType);   // GreaterThan
Console.WriteLine(corp.Right);      // 5

De aici diferența fundamentală dintre IEnumerable<T> și IQueryable<T> în LINQ: Enumerable.Where primește un Func și filtrează în memorie, iar Queryable.Where primește un Expression<Func>, pe care un provider (EF Core, de exemplu) îl traduce în SQL. Același cod sursă, x => x.Pret > 100, ajunge fie un apel de metodă, fie o clauză WHERE.

Limitări ale lambda-urilor convertite la arbori de expresie:

  • doar corp de tip expresie, nu blocuri cu instrucțiuni
  • fără async, fără atribuiri, fără unele construcții noi (de exemplu nu orice pattern matching)
  • un provider poate refuza la rulare metode pe care nu le știe traduce (de exemplu o metodă C# proprie într-o interogare EF Core)

Alte utilizări reale: construirea dinamică a filtrelor (Expression.AndAlso pentru căutări cu criterii opționale), biblioteci de mapare și validare care citesc numele proprietăților din p => p.Nume în loc de string-uri, generare de cod rapid la rulare ca alternativă la reflecție.

Ce urmărește intervievatorul: Testează înțelegerea mecanismului din spatele LINQ to SQL și EF Core. Un senior poate explica de ce o metodă proprie dă eroare într-o interogare.

LINQ în profunzime

66 Junior

Unde este bug-ul? Vrei angajații sortați după departament, iar în cadrul departamentului după nume.

C#
var sortati = angajati
    .OrderBy(a => a.Departament)
    .OrderBy(a => a.Nume)
    .ToList();

Răspuns scurt: Al doilea OrderBy resortează întreaga secvență după nume, iar departamentul devine doar criteriu secundar. Pentru criteriile următoare folosești ThenBy sau ThenByDescending.

OrderBy începe mereu o sortare nouă. Pentru că sortarea din LINQ este stabilă (elementele egale își păstrează ordinea relativă), rezultatul codului greșit este: angajați sortați după nume, iar cei cu același nume rămân în ordinea departamentului. Exact invers față de cerință.

Varianta corectă:

C#
public record Angajat(string Nume, string Departament, decimal Salariu);

var sortati = angajati
    .OrderBy(a => a.Departament)
    .ThenBy(a => a.Nume)
    .ToList();

var dupaSalariu = angajati
    .OrderBy(a => a.Departament)
    .ThenByDescending(a => a.Salariu)
    .ThenBy(a => a.Nume)
    .ToList();

ThenBy este disponibil doar pe IOrderedEnumerable<T>, tipul întors de OrderBy, deci compilatorul nu te lasă să-l folosești fără o sortare principală.

În sintaxa de interogare, criteriile multiple se scriu separate prin virgulă, iar compilatorul le transformă în OrderBy + ThenBy:

C#
var q = from a in angajati
        orderby a.Departament, a.Salariu descending
        select a;

Alte detalii utile:

  • pentru texte afișate oamenilor (nume cu diacritice), poți da un comparator: .ThenBy(a => a.Nume, StringComparer.Create(new CultureInfo("ro-RO"), ignoreCase: true))
  • din .NET 7 există Order() și OrderDescending() pentru sortarea după elementul însuși
  • OrderBy nu modifică lista originală; întoarce o secvență nouă, evaluată când o parcurgi; List<T>.Sort sortează pe loc și nu este stabil

Bug-ul apare des pentru că ambele variante compilează și dau un rezultat care arată „aproape bine” pe date de test mici.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre OrderBy repetat și ThenBy. Este o greșeală frecventă și greu de observat în code review.

67 Junior

Ce afișează codul următor? Când folosești Any() în loc de Count() > 0?

C#
var goala = new List<int>();
Console.WriteLine(goala.All(x => x > 100));
Console.WriteLine(goala.Any());
Console.WriteLine(goala.Any(x => x > 100));

Răspuns scurt: Afișează True, False, False. All pe o secvență goală este adevărat, pentru că nu există niciun element care să încalce condiția. Any() se oprește la primul element găsit, pe când Count() poate parcurge toată secvența.

All(conditie) întoarce false dacă găsește un element care nu respectă condiția, altfel true. Pe o secvență goală nu găsește niciun contraexemplu, deci rezultatul este true. Este convenția din logică (adevăr vacuu), dar produce bug-uri: „toate comenzile sunt livrate” este adevărat și când clientul nu are nicio comandă. Dacă regula ta cere cel puțin un element, scrii explicit:

C#
bool totulLivrat = comenzi.Any() && comenzi.All(c => c.Livrata);

Any() fără parametru verifică dacă există cel puțin un element, iar Any(conditie) dacă există cel puțin unul care respectă condiția. Ambele se opresc la primul rezultat pozitiv.

De ce Any() în loc de Count() > 0:

  • pe un IEnumerable<T> oarecare (rezultatul unui Where, un iterator, date citite dintr-un fișier), Count() trebuie să parcurgă toate elementele ca să le numere, deși tu vrei doar să știi dacă există unul
  • pe o colecție care știe deja numărul (List<T>, tablou), Count() folosește intern proprietatea Count, deci diferența dispare
  • pe IQueryable<T> (EF Core), Any() se traduce în EXISTS, care poate fi mai eficient decât COUNT(*)
C#
var mari = comenzi.Where(c => c.Total > 1000);
if (mari.Any()) { ... }         // se oprește la prima comandă mare
if (mari.Count() > 0) { ... }   // le numără pe toate

Pentru o List<T>, cel mai direct este lista.Count > 0 (proprietatea, nu metoda). Analizorul CA1860 recomandă proprietatea când există. Și nu folosi Count() == 0 pe secvențe mari doar ca să verifici golul: !Any() spune același lucru mai ieftin.

Ce urmărește intervievatorul: Verifică înțelegerea semanticii pe secvențe goale și a costului enumerării. Comportamentul lui All pe secvență goală surprinde mulți candidați.

Eroarea, în practică:Sequence contains no elements

68 Junior

Ce se întâmplă pe fiecare linie?

C#
var goala = new List<int>();
Console.WriteLine(goala.Sum());
Console.WriteLine(goala.Max());
Console.WriteLine(goala.Average());

var preturi = new List<decimal?>();
Console.WriteLine(preturi.Max() == null);

Răspuns scurt: Sum() întoarce 0, Max() și Average() aruncă InvalidOperationException pe o secvență goală de int, iar Max() pe decimal? întoarce null. Pentru agregări sigure pe date posibil goale folosești variantele nullable sau DefaultIfEmpty.

Logica din spate: suma unei mulțimi goale are o valoare naturală (0), dar minimul, maximul și media nu. Pentru tipurile valoare non-nullable, LINQ nu are ce să întoarcă și aruncă excepția „Sequence contains no elements”. Pentru tipuri nullable, null este răspunsul firesc pentru „nu există”.

Pe date reale, secvența goală apare des: un client fără comenzi, o zi fără vânzări, un filtru care nu găsește nimic. Variante sigure:

C#
var comenziAzi = comenzi.Where(c => c.Data == DateOnly.FromDateTime(DateTime.Today));

decimal? maxim = comenziAzi.Max(c => (decimal?)c.Total);       // null dacă nu sunt comenzi
decimal maxSauZero = comenziAzi.Select(c => c.Total).DefaultIfEmpty(0).Max();
double media = comenziAzi.Any() ? comenziAzi.Average(c => (double)c.Total) : 0;

var ceaMaiMare = comenziAzi.MaxBy(c => c.Total);                // elementul, nu valoarea (.NET 6)

Câteva detalii care apar la interviu:

  • Average() pe int întoarce double, deci new[] { 1, 2 }.Average() este 1,5, nu 1
  • Sum() pe int folosește aritmetică verificată și aruncă OverflowException la depășire, spre deosebire de o buclă obișnuită; pentru sume mari folosești long sau decimal: Sum(x => (long)x)
  • MaxBy și MinBy (.NET 6) întorc elementul cu valoarea maximă, ceea ce evită tiparul ineficient lista.First(x => x.Pret == lista.Max(y => y.Pret))
  • Min/Max pe tipuri proprii cer ca elementele să fie comparabile (IComparable<T>)

Varianta cu Any() urmat de Average() parcurge secvența de două ori; pentru o listă materializată nu contează, dar pentru o interogare costisitoare ai materializa întâi cu ToList().

Ce urmărește intervievatorul: Verifică dacă tratezi cazul secvenței goale, sursă frecventă de excepții în producție. Mulți candidați nu știu că Sum și Max se comportă diferit.

Eroarea, în practică:Sequence contains no elements

69 Junior

Ai o listă de clienți (clasă) și vrei clienții unici după email. De ce clienti.Distinct() nu elimină duplicatele și ce folosești în schimb?

Răspuns scurt: Distinct folosește egalitatea implicită a tipului, iar pentru o clasă aceasta compară referințele, deci două obiecte cu același email sunt considerate diferite. Folosești DistinctBy(c => c.Email) (.NET 6), un IEqualityComparer<T> sau un record.

Operatorii de mulțimi din LINQ (Distinct, Union, Intersect, Except) folosesc EqualityComparer<T>.Default. Pentru o clasă care nu suprascrie Equals și GetHashCode, două instanțe sunt egale doar dacă sunt același obiect. Clienții citiți din fișiere sau din baze de date diferite sunt obiecte distincte, chiar dacă au aceleași date.

Soluții, în funcție de context:

C#
public class Client
{
    public string Email { get; init; } = "";
    public string Nume { get; init; } = "";
}

// 1. .NET 6+: criteriul direct în apel, cu comparator pentru majuscule
var unici = clienti.DistinctBy(c => c.Email, StringComparer.OrdinalIgnoreCase).ToList();

// 2. Comparator reutilizabil
public class ClientDupaEmail : IEqualityComparer<Client>
{
    public bool Equals(Client? a, Client? b) =>
        string.Equals(a?.Email, b?.Email, StringComparison.OrdinalIgnoreCase);
    public int GetHashCode(Client c) => StringComparer.OrdinalIgnoreCase.GetHashCode(c.Email);
}
var unici2 = clienti.Distinct(new ClientDupaEmail()).ToList();

// 3. Grupare, când vrei să alegi explicit ce element păstrezi
var unici3 = clienti.GroupBy(c => c.Email.ToLowerInvariant())
                    .Select(g => g.OrderBy(c => c.Nume).First())
                    .ToList();

DistinctBy păstrează prima apariție. Dacă transformi Client într-un record, Distinct() funcționează direct, dar compară toate proprietățile, nu doar emailul.

Operațiile pe mulțimi întorc și ele elemente distincte, ceea ce surprinde:

C#
var a = new[] { 1, 1, 2, 3 };
var b = new[] { 3 };
Console.WriteLine(string.Join(",", a.Except(b)));    // 1,2 (nu 1,1,2)
Console.WriteLine(string.Join(",", a.Union(b)));     // 1,2,3

Există și variantele UnionBy, IntersectBy, ExceptBy din .NET 6, care primesc un selector de cheie.

Ce urmărește intervievatorul: Verifică legătura dintre LINQ și egalitatea tipurilor. Greșeala tipică este surpriza că Distinct „nu funcționează” pe clase.

70 Junior

Scrie o metodă care întoarce pagina n dintr-o listă de produse, cu marime elemente pe pagină. Ce face Chunk?

Răspuns scurt: Paginarea se face cu Skip((pagina - 1) * marime).Take(marime), după o sortare stabilă. Chunk(marime) (.NET 6) împarte o secvență în tablouri de câte marime elemente, ultimul putând fi mai mic.

Paginarea cu LINQ:

C#
static List<Produs> Pagina(IEnumerable<Produs> produse, int pagina, int marime)
{
    if (pagina < 1) throw new ArgumentOutOfRangeException(nameof(pagina));
    if (marime < 1) throw new ArgumentOutOfRangeException(nameof(marime));

    return produse
        .OrderBy(p => p.Nume)
        .ThenBy(p => p.Id)                  // ordine stabilă și unică
        .Skip((pagina - 1) * marime)
        .Take(marime)
        .ToList();
}

De ce contează fiecare detaliu:

  • sortarea este obligatorie pentru o paginare corectă; fără ea, ordinea nu e garantată (mai ales la baze de date), iar un element poate apărea pe două pagini sau pe niciuna
  • criteriul final unic (Id) evită ambiguitatea când două produse au același nume
  • validarea parametrilor: o pagină 0 ar produce un Skip negativ, pe care LINQ îl tratează ca 0, deci ai returna tacit prima pagină
  • Skip și Take nu aruncă excepții dacă depășești finalul; o pagină după ultima este pur și simplu goală

Chunk rezolvă o problemă înrudită: procesarea în loturi.

C#
foreach (Produs[] lot in produse.Chunk(100))
{
    TrimiteLaApi(lot);       // câte 100 deodată
}

var bucati = Enumerable.Range(1, 10).Chunk(4);   // [1,2,3,4], [5,6,7,8], [9,10]

Din .NET 6, Take acceptă și un interval: produse.Take(10..20) sau Take(^5..) pentru ultimele 5 elemente.

La performanță: pe un IEnumerable<T> în memorie, Skip(n) tot trebuie să parcurgă primele n elemente. Pentru pagini foarte îndepărtate în baze de date mari, paginarea pe bază de cheie (keyset: Where(p => p.Id > ultimulId).Take(marime)) este mult mai eficientă decât OFFSET.

Ce urmărește intervievatorul: Verifică dacă scrii cod de paginare corect, nu doar funcțional pe exemplu. Lipsa sortării este greșeala care contează cel mai mult.

71 Mid

Ai o listă de clienți și una de comenzi. Cum faci un inner join și cum obții toți clienții, inclusiv cei fără comenzi, cu totalul lor?

Răspuns scurt: Inner join-ul se face cu Join, iar „left join”-ul cu GroupJoin (sau join ... into în sintaxa de interogare), care dă fiecărui client grupul lui de comenzi, posibil gol. Din .NET 10 există și operatorul LeftJoin.

Datele de pornire:

C#
record Client(int Id, string Nume);
record Comanda(int Id, int ClientId, decimal Total);

Inner join: doar perechile care se potrivesc. Un client cu trei comenzi apare de trei ori, iar unul fără comenzi lipsește.

C#
var perechi = clienti.Join(comenzi,
    c => c.Id,               // cheia din stânga
    o => o.ClientId,         // cheia din dreapta
    (c, o) => new { c.Nume, o.Total });

Left join cu agregare: fiecare client apare o dată, cu grupul lui de comenzi.

C#
var totaluri = clienti.GroupJoin(comenzi,
    c => c.Id,
    o => o.ClientId,
    (c, comenziClient) => new { c.Nume, Total = comenziClient.Sum(o => o.Total) });

Pentru clienții fără comenzi, comenziClient este o secvență goală, iar Sum dă 0. Dacă vrei rânduri plate (câte unul pe comandă, cu null pentru clienții fără comenzi), sintaxa de interogare este mai lizibilă:

C#
var plat = from c in clienti
           join o in comenzi on c.Id equals o.ClientId into grup
           from o in grup.DefaultIfEmpty()
           select new { c.Nume, Total = o?.Total ?? 0 };

În .NET 10, clienti.LeftJoin(comenzi, c => c.Id, o => o.ClientId, (c, o) => ...) exprimă direct același lucru.

Ca performanță, Join și GroupJoin construiesc intern un lookup (tabel de hash) pe secvența din dreapta, deci complexitatea este aproximativ O(n + m). Varianta scrisă de mână cu clienti.Select(c => comenzi.Where(o => o.ClientId == c.Id)) este O(n × m) și devine lentă la volume mari. Alternativa explicită este var comenziPeClient = comenzi.ToLookup(o => o.ClientId); urmată de comenziPeClient[c.Id], care întoarce o secvență goală pentru cheile lipsă.

Ce urmărește intervievatorul: Verifică dacă știi să combini colecții în memorie corect și eficient. Mulți candidați nu știu cum se face left join în LINQ.

72 Mid

Ce face Aggregate? Scrie cu el produsul unor numere și calculul soldului după o serie de tranzacții.

Răspuns scurt: Aggregate este operația generală de „pliere”: pornește de la un acumulator și îl combină pe rând cu fiecare element. Sum, Max sau Count sunt cazuri particulare. Varianta fără valoare inițială aruncă excepție pe secvență goală.

Aggregate are trei forme:

C#
int[] numere = { 1, 2, 3, 4 };

// 1. fără seed: primul element devine acumulatorul inițial
int produs = numere.Aggregate((acc, x) => acc * x);          // 24

// 2. cu seed: valoare inițială și tip de acumulator propriu
decimal sold = tranzactii.Aggregate(1000m, (s, t) => t.Tip == "depunere" ? s + t.Suma : s - t.Suma);

// 3. cu seed și selector final
string text = new[] { "a", "b", "c" }.Aggregate(
    new StringBuilder(),
    (sb, s) => sb.Append(s).Append(';'),
    sb => sb.ToString().TrimEnd(';'));                        // "a;b;c"

Diferența dintre forme contează pe secvențe goale: new int[0].Aggregate((a, b) => a + b) aruncă InvalidOperationException, pentru că nu există primul element. Varianta cu seed întoarce seed-ul. Pentru calcule de business pe date posibil goale, folosește mereu seed-ul.

Un exemplu util la interviu este calculul unor statistici într-o singură trecere, cu un tuplu ca acumulator:

C#
var (min, max, suma) = numere.Aggregate(
    (Min: int.MaxValue, Max: int.MinValue, Suma: 0L),
    (acc, x) => (Math.Min(acc.Min, x), Math.Max(acc.Max, x), acc.Suma + x));

Când să nu folosești Aggregate:

  • când există un operator dedicat (Sum, Max, string.Join), care e mai clar și adesea optimizat
  • când logica de acumulare are mai multe ramuri sau efecte secundare; o buclă foreach cu variabile cu nume este mai ușor de citit și depanat
  • concatenarea de string-uri cu (a, b) => a + b creează un string nou la fiecare pas, deci este O(n²) ca memorie; string.Join sau StringBuilder rezolvă

Ce urmărește intervievatorul: Verifică înțelegerea operației generale din spatele agregărilor. Un candidat bun pomenește cazul secvenței goale și limitele de lizibilitate.

73 Mid

În ce ordine apar mesajele în cele două variante? Ce înseamnă operatori „streaming” și „buffering”?

C#
var numere = new[] { 3, 1, 2 };

var q1 = numere
    .Where(n => { Console.WriteLine($"Where {n}"); return true; })
    .Select(n => { Console.WriteLine($"Select {n}"); return n; });
foreach (var n in q1.Take(1)) { }

var q2 = numere
    .Where(n => { Console.WriteLine($"Where {n}"); return true; })
    .OrderBy(n => n)
    .Select(n => { Console.WriteLine($"Select {n}"); return n; });
foreach (var n in q2.Take(1)) { }

Răspuns scurt: Prima variantă afișează „Where 3”, „Select 3”: fiecare element trece pe rând prin tot lanțul și se oprește după primul. A doua afișează „Where 3”, „Where 1”, „Where 2”, „Select 1”, pentru că OrderBy trebuie să vadă toate elementele înainte să-l dea pe primul.

Interogările LINQ pe obiecte sunt lanțuri de iteratori. Când foreach cere un element, cererea urcă prin lanț până la sursă, iar elementul coboară prin fiecare operator. Nu se face întâi tot Where, apoi tot Select.

Operatorii se împart în două categorii:

  • streaming: produc rezultate pe măsură ce citesc sursa, element cu element: Where, Select, SelectMany, Take, Skip, Concat, Distinct (care ține în memorie doar cheile văzute)
  • buffering: trebuie să citească toată sursa înainte să întoarcă primul element: OrderBy, GroupBy, Reverse, ToList, ToDictionary, Join (pentru secvența din dreapta)

În prima variantă, Take(1) cere un element, Select îl cere de la Where, care îl cere de la tablou. Elementul 3 trece prin ambele, iar Take oprește enumerarea. Elementele 1 și 2 nu sunt atinse.

În a doua, OrderBy nu poate ști care element e cel mai mic până nu le-a văzut pe toate, deci consumă tot Where. Abia apoi dă primul element sortat (1), care trece prin Select.

Consecințe practice:

  • Take, First, Any pe un lanț streaming sunt ieftine chiar pe surse uriașe sau infinite; pe un lanț cu OrderBy costul include sortarea completă
  • poți procesa un fișier de mai mulți gigaocteți cu File.ReadLines(...).Where(...).Select(...) fără să-l încarci în memorie, dar un singur OrderBy în lanț îl aduce tot în memorie
  • pentru „cele mai mari 10 elemente” dintr-o secvență foarte mare, un PriorityQueue limitat la 10 elemente folosește mai puțină memorie decât OrderByDescending(...).Take(10)

Logurile din lambda-uri sunt utile pentru demonstrație, dar efectele secundare în interogări LINQ nu sunt o practică bună în cod real.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de execuție al LINQ, dincolo de „evaluare amânată”. Ordinea mesajelor din prima variantă surprinde mulți candidați.

74 Mid

Faci code review și găsești codul de mai jos într-un serviciu care procesează zeci de mii de comenzi. Ce comentarii lași și cum ai discuta cu autorul?

C#
foreach (var comanda in comenzi)
{
    var client = clienti.First(c => c.Id == comanda.ClientId);
    if (produseBlocate.ToList().Contains(comanda.ProdusId))
        continue;
    if (comenzi.Count(c => c.ClientId == client.Id) > 10)
        client.EsteFidel = true;
}

Răspuns scurt: Fiecare iterație face căutări liniare și reconstruiește o listă, deci totalul este O(n × m) sau chiar O(n²). Propun dicționare și seturi construite o singură dată înainte de buclă, cu măsurători înainte și după, și explic problema în termeni de complexitate, nu de stil.

Un răspuns structurat are două părți: problema tehnică și felul în care o comunici.

Problemele identificate:

  • clienti.First(...) în buclă: căutare liniară pentru fiecare comandă, O(n × m); în plus, First aruncă excepție dacă clientul lipsește
  • produseBlocate.ToList() în buclă: copiază colecția la fiecare iterație, apoi Contains liniar
  • comenzi.Count(...) în buclă peste comenzi: algoritm O(n²); pentru 50.000 de comenzi înseamnă ordinul a miliarde de comparații
  • client.EsteFidel = true se setează repetat pentru același client

Varianta propusă:

C#
var clientiDupaId = clienti.ToDictionary(c => c.Id);
var blocate = produseBlocate.ToHashSet();
var comenziPeClient = comenzi.GroupBy(c => c.ClientId)
                             .ToDictionary(g => g.Key, g => g.Count());

foreach (var comanda in comenzi)
{
    if (blocate.Contains(comanda.ProdusId)) continue;
    if (!clientiDupaId.TryGetValue(comanda.ClientId, out var client))
    {
        _log.LogWarning("Comanda {Id} are un client inexistent", comanda.Id);
        continue;
    }
    if (comenziPeClient[client.Id] > 10) client.EsteFidel = true;
}

Totul devine aproximativ O(n + m).

Cum discut cu autorul: comentariul descrie efectul, nu persoana („bucla face o căutare liniară pentru fiecare comandă, deci timpul crește pătratic”), propune concret alternativa și, ideal, aduce o măsurătoare: un test cu volumul real sau un benchmark rapid. Întreb și ce volume se așteaptă; pe zeci de elemente, codul original ar fi acceptabil și mai simplu. Dacă e o problemă recurentă în echipă, propun o scurtă sesiune despre complexitatea operațiilor pe colecții, în loc de comentarii repetate.

Mai menționez cazul clientului lipsă, care în codul original ar fi oprit toată procesarea cu o excepție.

Ce urmărește intervievatorul: Întrebare de situație care verifică atât ochiul pentru performanță, cât și felul în care colaborezi. Un răspuns bun cuantifică problema și rămâne constructiv.

75 Mid

Ai o listă de vânzări (categorie, produs, cantitate, preț unitar). Scrie o interogare LINQ care întoarce, pentru fiecare categorie, totalul încasat și produsul cel mai vândut ca număr de bucăți, ordonate descrescător după total.

Răspuns scurt: Grupezi după categorie, calculezi în fiecare grup suma Cantitate * PretUnitar, iar pentru produsul cel mai vândut grupezi din nou după produs în interiorul grupului și iei maximul cu MaxBy. La final ordonezi după total.

O soluție completă, cu tipuri clare:

C#
public record Vanzare(string Categorie, string Produs, int Cantitate, decimal PretUnitar);
public record RandRaport(string Categorie, decimal Total, string CelMaiVandut);

static List<RandRaport> Raport(IEnumerable<Vanzare> vanzari) =>
    vanzari
        .GroupBy(v => v.Categorie)
        .Select(g => new RandRaport(
            g.Key,
            g.Sum(v => v.Cantitate * v.PretUnitar),
            g.GroupBy(v => v.Produs)
             .MaxBy(p => p.Sum(v => v.Cantitate))!
             .Key))
        .OrderByDescending(r => r.Total)
        .ThenBy(r => r.Categorie)
        .ToList();

var vanzari = new List<Vanzare>
{
    new("Papetărie", "Caiet", 10, 5m),
    new("Papetărie", "Pix", 25, 2m),
    new("Electronice", "Mouse", 2, 80m),
};

foreach (var r in Raport(vanzari))
    Console.WriteLine($"{r.Categorie,-12} {r.Total,10:N2} {r.CelMaiVandut}");

Explicații pe care le dai în timp ce scrii:

  • GroupBy întoarce IGrouping<string, Vanzare>: o cheie (g.Key) și elementele grupului
  • v.Cantitate * v.PretUnitar înmulțește un int cu un decimal, deci rezultatul e decimal, fără pierderi
  • MaxBy (.NET 6) întoarce grupul de produse cu suma maximă de bucăți; operatorul ! spune compilatorului că rezultatul nu e null, ceea ce e adevărat pentru că un grup are cel puțin un element
  • ThenBy(r => r.Categorie) face ordinea deterministă când două categorii au același total
  • un record în loc de tip anonim permite întoarcerea rezultatului din metodă

Întrebări de clarificare pe care merită să le pui: ce se întâmplă la egalitate între două produse (aici MaxBy îl ia pe primul găsit)? Vânzările pot avea cantități negative (retururi)? Datele vin din memorie sau dintr-o bază de date? În al doilea caz, interogarea ar trebui verificată, pentru că MaxBy imbricat nu se traduce bine în SQL cu orice provider.

Ce urmărește intervievatorul: Este o problemă tipică de cod live cu LINQ. Intervievatorul urmărește grupările imbricate, tipurile numerice și întrebările de clarificare.

76 Senior

Când ai înlocui LINQ cu bucle clasice? Ce costuri ascunse are LINQ într-o metodă apelată de milioane de ori?

Răspuns scurt: LINQ alocă iteratori, delegați și uneori closure-uri, și face apeluri indirecte prin delegați pentru fiecare element. În cod fierbinte, măsurat cu un profiler sau benchmark, o buclă for pe tablou sau Span<T> poate elimina alocările; în restul codului, lizibilitatea LINQ câștigă.

Costurile tipice ale unei interogări LINQ pe obiecte:

  • alocări: fiecare operator (Where, Select) creează un obiect iterator; o lambda care capturează variabile locale alocă un closure; ToList alocă lista și eventual o redimensionează
  • apeluri indirecte: pentru fiecare element se apelează un delegat, ceea ce împiedică de obicei inlining-ul făcut de JIT
  • enumerare prin interfețe: IEnumerator<T>.MoveNext și Current sunt apeluri virtuale, față de accesul direct la index într-un tablou

Un exemplu dintr-o metodă fierbinte:

C#
// LINQ: iterator Where, delegat, closure pentru prag
int Numara(int[] valori, int prag) => valori.Count(v => v > prag);

// buclă: zero alocări
int NumaraRapid(ReadOnlySpan<int> valori, int prag)
{
    int n = 0;
    foreach (int v in valori)
        if (v > prag) n++;
    return n;
}

Biblioteca s-a îmbunătățit mult: în .NET 7 și 8, Sum, Min, Max, Average pe tablouri și liste de numere sunt vectorizate (folosesc instrucțiuni SIMD) și pot fi mai rapide decât o buclă naivă. Deci nu presupune că LINQ e lent; măsoară.

Procesul pe care l-aș descrie la interviu:

  • identific codul fierbinte cu un profiler (dotnet-trace, PerfView, profilerul din Visual Studio sau Rider), nu după intuiție
  • scriu un benchmark cu BenchmarkDotNet și [MemoryDiagnoser], ca să văd timp și alocări
  • rescriu doar metoda dovedită problematică și păstrez varianta lizibilă în teste, ca referință de corectitudine

Pentru 95% din cod (servicii, rapoarte, validări), costul LINQ este neglijabil față de I/O. Optimizarea prematură a lor face codul mai greu de întreținut fără câștig real.

Ce urmărește intervievatorul: Verifică echilibrul dintre performanță și lizibilitate și dacă optimizezi pe baza măsurătorilor. Un senior știe și de îmbunătățirile recente din .NET.

Excepții și resurse

77 Junior

De ce nu compilează codul următor? În ce ordine se scriu blocurile catch?

C#
try
{
    int n = int.Parse(Console.ReadLine()!);
}
catch (Exception ex)
{
    Console.WriteLine("Eroare generală");
}
catch (FormatException ex)
{
    Console.WriteLine("Nu ai introdus un număr");
}

Răspuns scurt: Primul catch prinde orice excepție, deci al doilea nu ar putea fi atins niciodată, iar compilatorul dă eroarea CS0160. Blocurile se scriu de la cel mai specific tip de excepție la cel mai general.

La aruncarea unei excepții, blocurile catch sunt verificate în ordinea în care sunt scrise, iar primul compatibil cu tipul excepției câștigă. Pentru că FormatException derivă din Exception, un catch (Exception) pus primul ar prinde și excepțiile de format. Compilatorul detectează blocul inaccesibil și refuză codul.

Varianta corectă:

C#
try
{
    int n = int.Parse(Console.ReadLine()!);
    Console.WriteLine(100 / n);
}
catch (FormatException)
{
    Console.WriteLine("Nu ai introdus un număr");
}
catch (OverflowException)
{
    Console.WriteLine("Numărul este prea mare");
}
catch (DivideByZeroException)
{
    Console.WriteLine("Nu pot împărți la zero");
}

Dacă nu folosești obiectul excepției, poți omite numele variabilei (catch (FormatException)), ceea ce evită și avertismentul de variabilă nefolosită.

Pentru mai multe tipuri tratate la fel, folosești un filtru:

C#
catch (Exception ex) when (ex is FormatException or OverflowException)
{
    Console.WriteLine("Valoare invalidă");
}

Ierarhia merită cunoscută în linii mari: Exception este baza; ArgumentNullException și ArgumentOutOfRangeException derivă din ArgumentException; FileNotFoundException derivă din IOException; TaskCanceledException derivă din OperationCanceledException.

Regula de fond: prinzi doar excepțiile pe care știi să le tratezi într-un mod util. Un catch (Exception) în fiecare metodă ascunde bug-uri. Locul lui natural este la granița aplicației (bucla principală, un middleware), unde loghezi și afișezi un mesaj generic. Iar în exemplul de față, cea mai bună soluție nici nu folosește excepții: int.TryParse tratează intrarea invalidă ca pe un caz normal.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de potrivire a excepțiilor. Un răspuns bun pomenește și când nu trebuie prinsă o excepție.

Eroarea, în practică:FormatException: input string not in correct formatCS0160: A previous catch clause already catches all

78 Junior

Cum scrii corect o excepție proprie? Arată un exemplu pentru stoc insuficient într-un magazin.

Răspuns scurt: Derivezi din Exception (sau dintr-o excepție standard potrivită), numele se termină în Exception, transmiți un mesaj clar la constructorul de bază, adaugi proprietăți cu datele relevante și oferi un constructor cu innerException.

O excepție proprie are sens când apelantul trebuie să poată trata acea situație separat de altele, iar o excepție standard nu exprimă suficient de clar ce s-a întâmplat.

C#
public class StocInsuficientException : Exception
{
    public string Produs { get; } = "";
    public int Cerut { get; }
    public int Disponibil { get; }

    public StocInsuficientException(string produs, int cerut, int disponibil)
        : base($"Stoc insuficient pentru {produs}: cerut {cerut}, disponibil {disponibil}")
    {
        Produs = produs;
        Cerut = cerut;
        Disponibil = disponibil;
    }

    public StocInsuficientException(string mesaj, Exception inner) : base(mesaj, inner) { }
}

// aruncare
if (stoc < cantitate)
    throw new StocInsuficientException(produs, cantitate, stoc);

// tratare
catch (StocInsuficientException ex)
{
    Console.WriteLine($"Mai avem doar {ex.Disponibil} bucăți din {ex.Produs}");
}

Reguli de bune practici:

  • numele se termină în Exception
  • derivă din Exception, nu din ApplicationException (recomandare veche, abandonată)
  • mesajul descrie problema pentru un om care citește logul; datele structurate stau în proprietăți, ca apelantul să nu fie nevoit să parseze mesajul
  • constructorul cu innerException permite păstrarea cauzei inițiale când împachetezi o excepție de nivel jos (de exemplu o eroare SQL)
  • constructorul de serializare binară, des întâlnit în exemple vechi, nu mai e necesar; în .NET 8 API-ul respectiv este marcat învechit (SYSLIB0051)

Înainte să creezi o excepție nouă, verifică dacă una standard se potrivește: ArgumentException pentru argumente invalide, InvalidOperationException pentru o operație nepermisă în starea curentă, NotSupportedException, KeyNotFoundException. O ierarhie mare de excepții proprii complică tratarea fără câștig.

Ce urmărește intervievatorul: Verifică dacă știi convențiile .NET pentru excepții. Greșelile tipice sunt lipsa datelor structurate și crearea de excepții acolo unde există deja una standard.

Eroarea, în practică:CS0155: must be derived from System.Exception

79 Junior

Ce afișează codul următor?

C#
static int Test()
{
    int x = 1;
    try
    {
        return x;
    }
    finally
    {
        x = 10;
        Console.WriteLine("finally");
    }
}

Console.WriteLine(Test());

Răspuns scurt: Afișează „finally” și apoi 1. Valoarea de retur se evaluează când se execută return, înainte de blocul finally; modificarea lui x din finally nu mai schimbă rezultatul.

Blocul finally rulează întotdeauna la ieșirea din try, fie că ieșirea se face normal, prin return, prin break, sau printr-o excepție. Ordinea exactă la return x; este:

  • se evaluează expresia x (valoarea 1) și se păstrează ca rezultat
  • rulează finally: x devine 10, se afișează „finally”
  • metoda se termină și întoarce valoarea păstrată, 1

Pentru tipuri valoare, rezultatul este o copie, deci schimbarea variabilei nu mai contează. Pentru tipuri referință, situația e diferită: dacă return lista; și în finally faci lista.Add(...), apelantul vede modificarea, pentru că a primit o referință la același obiect.

Reguli legate de finally:

  • nu poți scrie return în finally (eroarea CS0157); C# interzice asta tocmai ca să nu poți înlocui tacit rezultatul sau înghiți o excepție
  • finally nu rulează dacă procesul este oprit brusc: Environment.FailFast, oprirea forțată a procesului, StackOverflowException (care nu poate fi prinsă în .NET modern)
  • o excepție aruncată din finally o înlocuiește pe cea originală, care se pierde

Rolul lui finally este eliberarea resurselor indiferent de rezultat:

C#
var lacat = new object();
Monitor.Enter(lacat);
try
{
    // lucru cu resursa
}
finally
{
    Monitor.Exit(lacat);   // se eliberează chiar dacă apare o excepție
}

În practică, pentru resurse IDisposable folosești using, care generează exact un try/finally, iar pentru lock-uri folosești lock, care face același lucru ca exemplul de mai sus.

Ce urmărește intervievatorul: Verifică înțelegerea precisă a ordinii de execuție. Mulți candidați răspund 10.

Eroarea, în practică:CS0157: Control cannot leave the finally clause

80 Junior

Când arunci o excepție și când întorci un rezultat de eroare? Validarea datelor dintr-un formular ar trebui să arunce excepții?

Răspuns scurt: Excepțiile sunt pentru situații neașteptate, care încalcă presupunerile codului (argument null, fișier de configurare lipsă). Situațiile așteptate, ca datele invalide introduse de un utilizator, se tratează cu valori de retur: bool cu TryXxx, un obiect rezultat sau o listă de erori de validare.

Criteriul principal este dacă situația face parte din fluxul normal al aplicației.

Excepții, pentru:

  • încălcarea contractului unei metode: argumente invalide transmise de alt programator
  • stări imposibile sau neașteptate: o configurare lipsă, o resursă externă căzută
  • erori de la care metoda curentă nu știe să se refacă
C#
public void Transfera(Cont sursa, Cont destinatie, decimal suma)
{
    ArgumentNullException.ThrowIfNull(sursa);              // .NET 6
    ArgumentNullException.ThrowIfNull(destinatie);
    ArgumentOutOfRangeException.ThrowIfNegativeOrZero(suma); // .NET 8
    ...
}

Rezultate, pentru situații așteptate: utilizatorul greșește un câmp, un produs nu mai este pe stoc, o căutare nu găsește nimic.

C#
public record Rezultat<T>(bool Succes, T? Valoare, string? Eroare)
{
    public static Rezultat<T> Ok(T valoare) => new(true, valoare, null);
    public static Rezultat<T> Esec(string eroare) => new(false, default, eroare);
}

public Rezultat<Comanda> Plaseaza(FormularComanda f)
{
    if (string.IsNullOrWhiteSpace(f.Adresa))
        return Rezultat<Comanda>.Esec("Adresa este obligatorie");
    return Rezultat<Comanda>.Ok(new Comanda(f.Adresa));
}

De ce contează:

  • o excepție costă: runtime-ul capturează stack trace-ul și derulează stiva, operații mult mai lente decât un if; în fluxuri cu multe erori așteptate, diferența se vede
  • excepțiile folosite pentru control fac fluxul greu de urmărit, ca un goto invizibil
  • un rezultat explicit obligă apelantul să trateze eșecul, pe când o excepție poate fi uitată

Pentru validarea unui formular, răspunsul bun este: colectezi toate erorile într-o listă și le întorci împreună, ca utilizatorul să le vadă pe toate deodată. Excepția ar opri la prima. Bibliotecile ca FluentValidation urmează acest model.

Ce urmărește intervievatorul: Verifică judecata de design, nu cunoașterea sintaxei. Răspunsurile slabe sunt „mereu excepții” sau „niciodată excepții”.

81 Mid

Ce sunt filtrele de excepții (catch ... when)? Prin ce diferă de un if în interiorul blocului catch?

C#
try
{
    return await client.GetStringAsync(url);
}
catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
{
    return null;
}

Răspuns scurt: Un filtru when decide dacă blocul catch prinde excepția. Dacă e fals, excepția continuă să urce ca și cum blocul n-ar exista, fără derularea stivei. Un if cu throw; în catch prinde întâi excepția, apoi o aruncă din nou.

Diferența se vede în modul în care runtime-ul tratează excepțiile, în două faze: întâi caută un handler potrivit urcând pe stivă, apoi derulează stiva până la el, rulând blocurile finally. Filtrele se evaluează în prima fază. Dacă filtrul întoarce false, căutarea continuă mai sus, fără ca stiva să fie derulată în acel punct.

Comparația:

C#
// cu if: excepția e prinsă, apoi aruncată din nou
catch (HttpRequestException ex)
{
    if (ex.StatusCode != HttpStatusCode.NotFound)
        throw;
    return null;
}

// cu filtru: excepțiile care nu sunt 404 nu sunt prinse deloc
catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
{
    return null;
}

Avantajele filtrului:

  • codul exprimă intenția mai clar: „tratez doar 404”
  • la un crash, un memory dump sau debugger-ul arată starea exactă din momentul aruncării, inclusiv variabilele locale, pentru că stiva nu a fost derulată
  • poți avea mai multe blocuri catch pentru același tip, cu filtre diferite

Un tipar cunoscut folosește un filtru care întoarce mereu false pentru logare fără să interferezi cu tratarea:

C#
catch (Exception ex) when (Logheaza(ex))
{
    // nu ajunge niciodată aici
}

static bool Logheaza(Exception ex)
{
    Console.Error.WriteLine(ex);
    return false;
}

Proprietatea HttpRequestException.StatusCode există din .NET 5. Alte filtre utile: when (ex.InnerException is SqlException { Number: 1205 }) pentru deadlock-uri în SQL Server, sau when (!ct.IsCancellationRequested) ca să nu tratezi ca eroare o anulare cerută de utilizator.

Atenție: un filtru nu trebuie să arunce excepții sau să aibă efecte secundare importante (în afară de logare), pentru că rulează într-un moment neobișnuit al tratării.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de tratare a excepțiilor. Puțini candidați știu că filtrul nu derulează stiva.

82 Mid

Ce diferență este între using var și blocul using (...) { }? Unde e bug-ul în metoda de mai jos?

C#
static StreamReader DeschideFisier(string cale)
{
    using var cititor = new StreamReader(cale);
    return cititor;
}

Răspuns scurt: using var (C# 8) eliberează resursa la sfârșitul blocului în care e declarată variabila, de obicei sfârșitul metodei, iar blocul using o eliberează la acolada lui de închidere. Metoda întoarce un StreamReader deja închis, deci apelantul primește ObjectDisposedException la citire.

Ambele forme generează un try/finally care apelează Dispose(). Diferă doar domeniul de valabilitate:

C#
static string PrimaLinie(string cale)
{
    using var cititor = new StreamReader(cale);
    return cititor.ReadLine() ?? "";
}   // Dispose aici, după ce s-a calculat valoarea de retur

static void Proceseaza(string cale)
{
    string continut;
    using (var cititor = new StreamReader(cale))
    {
        continut = cititor.ReadToEnd();
    }   // fișierul se închide aici
    ProcesareLunga(continut);   // fișierul nu mai e blocat cât durează procesarea
}

using var reduce indentarea, dar prelungește viața resursei până la sfârșitul metodei. Dacă după folosire urmează operații lungi, blocul explicit eliberează fișierul, conexiunea sau lock-ul mai devreme.

În metoda din întrebare, Dispose() rulează la ieșirea din metodă, deci obiectul întors este deja închis. Regula: dacă metoda transferă proprietatea resursei către apelant, nu o pune în using; apelantul devine responsabil de eliberare.

C#
static StreamReader DeschideFisier(string cale) => new StreamReader(cale);

using var r = DeschideFisier("date.txt");   // apelantul eliberează

Pentru resurse cu eliberare asincronă (fluxuri de rețea, conexiuni la baze de date), există IAsyncDisposable și await using:

C#
await using var flux = new FileStream("date.bin", FileMode.Open, FileAccess.Read,
                                      FileShare.Read, 4096, useAsync: true);

await using apelează DisposeAsync(), care poate goli bufferele fără să blocheze firul de execuție.

Capcana similară apare cu iteratorii: using într-o metodă care întoarce un IEnumerable<T> construit cu LINQ peste resursă, fără yield return, eliberează resursa înainte ca apelantul să înceapă enumerarea.

Ce urmărește intervievatorul: Verifică dacă înțelegi durata de viață a resurselor și cine are responsabilitatea eliberării. Bug-ul cu resursa întoarsă după using este frecvent.

Eroarea, în practică:ObjectDisposedException: disposed objectCS1674: using requires IDisposable

83 Mid

O aplicație C# aruncă intermitent NullReferenceException în producție, iar local nu reușești să o reproduci. Cum ai investiga?

Răspuns scurt: Pornesc de la stack trace-ul complet din loguri, identific exact expresia care e null, reconstitui datele și contextul (utilizator, cerere, concurență), scriu un test care reproduce situația, repar cauza, nu simptomul, și adaug protecții: nullable reference types, validări la granițe și logare cu context.

Un răspuns structurat, pe pași:

1. Strâng informația existentă. Stack trace-ul complet, cu numerele de linie (care cer fișierele PDB publicate alături de aplicație), ora, frecvența, versiunea aplicației și orice context logat: identificatorul cererii, utilizatorul, datele de intrare.

2. Identific expresia exactă. O linie ca comanda.Client.Adresa.Oras are trei candidați. Dacă stack trace-ul nu e suficient, adaug temporar logare sau separ expresia pe mai multe linii.

3. Formulez ipoteze despre cauză. Cele mai frecvente:

  • date din producție pe care testele nu le acoperă (un client vechi fără adresă, o coloană NULL în baza de date, un câmp lipsă din JSON)
  • o condiție de cursă: un obiect partajat între fire, inițializat leneș sau modificat în paralel; explică perfect caracterul intermitent
  • un serviciu extern care întoarce uneori un răspuns gol
  • configurare diferită între medii

4. Reproduc într-un test. Cu datele suspecte sau cu un test de concurență. Fără reproducere, nu știu dacă reparația funcționează.

5. Repar cauza. Dacă Adresa poate lipsi legitim, modelul trebuie să spună asta (Adresa?) și codul să trateze cazul. Nu presar ?. peste tot, pentru că asta ascunde problema și o mută în altă parte, ca date greșite.

6. Previn repetarea. Activez sau respect nullable reference types și tratez avertismentele, validez datele la intrarea în sistem, adaug logare structurată cu contextul care mi-a lipsit.

Spre deosebire de Java, unde mesajul excepției echivalente numește variabila, în .NET mesajul unui NullReferenceException nu spune ce membru era null, deci separarea expresiilor și logarea cu context rămân importante.

Ce urmărește intervievatorul: Întrebare de situație care verifică metoda de depanare, nu cunoașterea unei unelte. Un răspuns slab sare direct la „pun ?.”.

Eroarea, în practică:NullReferenceException: Object reference not set

84 Senior

Ce afișează codul următor? Cum poate fi pierdută o excepție și cum o arunci din nou fără să pierzi stack trace-ul original?

C#
try
{
    try
    {
        throw new InvalidOperationException("original");
    }
    finally
    {
        throw new IOException("din finally");
    }
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

Răspuns scurt: Afișează „din finally”: excepția aruncată în finally o înlocuiește complet pe cea originală, care se pierde. Pentru a arunca din nou o excepție capturată în alt loc, păstrând stack trace-ul, folosești ExceptionDispatchInfo.Capture(ex).Throw().

Când o excepție este în curs de propagare și un bloc finally aruncă una nouă, runtime-ul o abandonează pe prima. Nu există niciun lanț între ele (cea nouă nu are InnerException setat). Situația este periculoasă, pentru că în loguri vezi un simptom secundar, iar cauza reală dispare.

Același lucru se întâmplă, mai discret, cu using: dacă Dispose() aruncă o excepție în timp ce blocul using era părăsit din cauza altei excepții, cea originală se pierde. De aceea ghidurile .NET cer ca Dispose să nu arunce excepții.

Cum previi:

  • codul din finally și din Dispose trebuie să fie sigur; dacă poate eșua, îl protejezi cu propriul try/catch și loghezi eroarea secundară
  • dacă ambele erori contează, le combini explicit, de exemplu într-un AggregateException

A doua parte a întrebării ține de aruncarea din nou:

  • throw; în interiorul unui catch păstrează stack trace-ul
  • throw ex; îl resetează la linia curentă
  • când excepția a fost prinsă într-un loc și trebuie aruncată în altul (alt fir, după o coadă de mesaje), throw; nu mai e posibil
C#
ExceptionDispatchInfo? eroare = null;
try
{
    Proceseaza();
}
catch (Exception ex)
{
    eroare = ExceptionDispatchInfo.Capture(ex);
}

// mai târziu, eventual pe alt fir
eroare?.Throw();   // stack trace-ul original plus locul noii aruncări

Exact acest mecanism îl folosește await: când un Task eșuat este așteptat, excepția este aruncată din nou cu ExceptionDispatchInfo, de aceea stack trace-ul unei excepții async arată și locul inițial. Pentru împachetare, varianta corectă rămâne throw new ServiciuException("context", ex);, care păstrează originalul în InnerException.

Ce urmărește intervievatorul: Verifică înțelegerea fină a propagării excepțiilor. Un senior cunoaște ExceptionDispatchInfo și legătura lui cu await.

async/await și Task

Exersează capitolul cu exerciții reale: Curs C# →
85 Junior

În ce ordine apar cifrele?

C#
Console.WriteLine("1");
Task t = LucreazaAsync();
Console.WriteLine("3");
await t;
Console.WriteLine("5");

static async Task LucreazaAsync()
{
    Console.WriteLine("2");
    await Task.Delay(100);
    Console.WriteLine("4");
}

Răspuns scurt: Apar în ordinea 1, 2, 3, 4, 5. O metodă async rulează sincron, pe firul apelantului, până la primul await pe o operație neterminată; abia atunci întoarce controlul apelantului, care continuă cu „3”.

Mulți presupun că apelul unei metode async pornește imediat un fir nou de execuție. Nu este așa. Pas cu pas:

  • se afișează „1”
  • apelul LucreazaAsync() intră în metodă pe același fir și afișează „2”
  • await Task.Delay(100) găsește o sarcină neterminată; metoda își salvează starea, înregistrează continuarea (restul metodei) și întoarce imediat un Task neterminat
  • apelantul primește t și afișează „3”
  • await t suspendă apelantul până când t se termină
  • după 100 ms, continuarea metodei rulează și afișează „4”, apoi t se termină
  • apelantul continuă și afișează „5”

Cuvântul cheie async nu face o metodă să ruleze în fundal; doar permite folosirea lui await în ea. await nu blochează firul: îl eliberează pentru alte lucruri cât timp operația așteaptă.

Consecință importantă: dacă o metodă async face mult calcul înainte de primul await, apelantul este blocat tot acel timp:

C#
static async Task<int> CalculeazaAsync()
{
    int rezultat = CalculGreuSincron();   // blochează apelantul
    await Task.Delay(1);
    return rezultat;
}

Dacă operația așteptată este deja terminată (de exemplu un rezultat din cache), await continuă sincron, fără nicio suspendare.

Pe care fir rulează „4” depinde de context: într-o aplicație consolă, pe un fir din thread pool; într-o aplicație WPF sau WinForms, înapoi pe firul interfeței, prin contextul de sincronizare. În ASP.NET Core nu există context de sincronizare, deci pe orice fir din pool.

Ce urmărește intervievatorul: Verifică modelul mental corect al lui async/await. Răspunsul greșit tipic este 1, 3, 2, 4, 5.

86 Junior

Care este diferența dintre o operație CPU-bound și una I/O-bound? Când folosești Task.Run și când nu?

Răspuns scurt: O operație CPU-bound ține procesorul ocupat (calcule, compresie), iar una I/O-bound așteaptă un dispozitiv sau rețeaua (HTTP, bază de date, fișiere). Pentru I/O folosești direct API-urile async; Task.Run mută lucrul CPU-bound pe thread pool, util mai ales ca să nu blochezi interfața grafică.

Distincția determină unealta potrivită.

I/O-bound: codul trimite o cerere și așteaptă răspunsul. În acest timp, procesorul nu are nimic de făcut pentru operația ta. API-urile async ale .NET (HttpClient.GetStringAsync, File.ReadAllTextAsync, DbCommand.ExecuteReaderAsync) folosesc mecanismele sistemului de operare, iar în timpul așteptării niciun fir nu este ocupat. Așa poate un server să trateze mii de cereri simultane cu câteva zeci de fire.

C#
string json = await client.GetStringAsync(url);          // corect
string text = await File.ReadAllTextAsync("date.txt");    // corect

CPU-bound: procesorul lucrează efectiv. await singur nu ajută, pentru că lucrul trebuie făcut oricum de un fir. Task.Run îl mută pe un fir din thread pool:

C#
// într-o aplicație WPF: interfața rămâne responsivă
var raport = await Task.Run(() => GenereazaRaportComplex(date));

Greșeli frecvente:

  • await Task.Run(() => File.ReadAllText(cale)): ocupă un fir din pool cât așteaptă discul; folosește File.ReadAllTextAsync
  • Task.Run într-un controller ASP.NET Core pentru calcule: cererea e deja pe un fir din pool, deci doar muți lucrul pe alt fir din același pool, cu cost suplimentar și fără câștig
  • o metodă de bibliotecă CalculeazaAsync() care e doar un Task.Run peste cod sincron; apelantul crede că e I/O asincron. Recomandarea este ca bibliotecile să expună metoda sincronă, iar apelantul să decidă dacă o împachetează în Task.Run

Pentru prelucrarea paralelă a multor date CPU-bound, Parallel.For, Parallel.ForEach sau PLINQ (AsParallel) împart lucrul pe mai multe nuclee.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce există async, nu doar sintaxa. Folosirea lui Task.Run pentru I/O este greșeala cea mai frecventă.

87 Junior

Ce probleme are metoda următoare?

C#
public async Task PlaseazaComandaAsync(Comanda c)
{
    TrimiteEmailConfirmareAsync(c);
    await _repository.SalveazaAsync(c);
}

Răspuns scurt: Apelul către TrimiteEmailConfirmareAsync nu este așteptat (compilatorul dă avertismentul CS4014): emailul poate pleca înainte ca comanda să fie salvată, o excepție la trimitere se pierde, iar metoda se poate termina înainte de trimitere.

Apelul unei metode async fără await pornește operația și primește un Task, care aici este aruncat. Consecințele:

  • ordinea: emailul și salvarea rulează în paralel; clientul poate primi confirmarea pentru o comandă care apoi nu se salvează din cauza unei erori
  • excepțiile se pierd: dacă trimiterea eșuează, excepția rămâne în Task-ul pe care nu îl observă nimeni; nu ajunge în loguri, nu oprește nimic
  • durata de viață: în ASP.NET Core, după terminarea cererii, serviciile scoped (de exemplu DbContext) sunt eliberate; dacă emailul folosește unul dintre ele, poate eșua cu ObjectDisposedException
  • testele: un test care verifică trimiterea emailului poate trece sau pica aleatoriu

Varianta corectă, dacă emailul face parte din operație:

C#
public async Task PlaseazaComandaAsync(Comanda c)
{
    await _repository.SalveazaAsync(c);
    await TrimiteEmailConfirmareAsync(c);
}

Dacă emailul nu trebuie să întârzie răspunsul, soluția nu este un apel fără await, ci o coadă: salvezi o cerere de trimitere (în baza de date, într-un Channel<T> consumat de un BackgroundService, sau într-un broker de mesaje), iar trimiterea se face separat, cu reîncercări și logare.

Avertismentul CS4014 apare doar când metoda curentă este async. Dacă metoda apelantă nu e async, compilatorul tace, iar bug-ul trece neobservat. Merită tratat ca eroare în proiect (<WarningsAsErrors>CS4014</WarningsAsErrors>). Dacă un apel fără await este cu adevărat intenționat, îl marchezi explicit cu un discard: _ = TrimiteAsync(c);, ca cititorul să știe că ai decis conștient, și te asiguri că metoda își tratează singură excepțiile.

Ce urmărește intervievatorul: Verifică dacă recunoști un fire-and-forget accidental și consecințele lui. Un candidat bun propune o coadă pentru lucrul în fundal.

88 Mid

Ce afișează codul următor? Cum obții toate excepțiile când mai multe sarcini eșuează?

C#
static async Task EsueazaAsync(string mesaj)
{
    await Task.Delay(10);
    throw new InvalidOperationException(mesaj);
}

var toate = Task.WhenAll(EsueazaAsync("A"), EsueazaAsync("B"));
try
{
    await toate;
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
    Console.WriteLine(toate.Exception!.InnerExceptions.Count);
}

Răspuns scurt: Afișează mesajul uneia dintre excepții („A” sau „B”) și 2. await pe un task eșuat aruncă doar prima excepție, iar Task.WhenAll le păstrează pe toate în proprietatea Exception, un AggregateException cu InnerExceptions.

Un Task eșuat stochează excepțiile într-un AggregateException, pentru că o sarcină compusă poate avea mai multe cauze de eșec. Cele două moduri de a aștepta un task se comportă diferit:

  • await task despachetează și aruncă prima excepție din listă, cu stack trace-ul original; așa codul async arată ca cel sincron, cu catch (InvalidOperationException)
  • task.Wait() sau task.Result aruncă AggregateException întreg, ceea ce obligă la despachetare manuală (și au și problema blocării firului)

La Task.WhenAll, toate sarcinile rulează până la capăt, chiar dacă una eșuează devreme. Rezultatul combinat conține toate excepțiile, dar ordinea lor nu este garantată: aici cele două sarcini eșuează aproape simultan, iar rulări repetate pot afișa „A” sau „B”. Nu te baza pe ordine. Codul din catch vede doar prima, dar le poți citi pe toate din task-ul păstrat:

C#
var sarcini = urls.Select(u => client.GetStringAsync(u)).ToList();
var toate = Task.WhenAll(sarcini);
try
{
    await toate;
}
catch
{
    foreach (var e in toate.Exception!.InnerExceptions)
        _log.LogError(e, "Descărcare eșuată");

    var reusite = sarcini.Where(t => t.IsCompletedSuccessfully).Select(t => t.Result);
}

Observații:

  • rezultatele sarcinilor reușite rămân disponibile, chiar dacă WhenAll a eșuat; citirea lui .Result pe o sarcină terminată cu succes este sigură
  • dacă o sarcină eșuată nu este niciodată așteptată sau observată, excepția ei ajunge la evenimentul TaskScheduler.UnobservedTaskException, dar nu mai oprește procesul în .NET modern; altfel spus, se pierde în tăcere
  • în .NET 9 există Task.WhenEach, care permite tratarea fiecărei sarcini pe măsură ce se termină

Ce urmărește intervievatorul: Verifică înțelegerea propagării excepțiilor în cod async. Mulți candidați nu știu că restul excepțiilor pot fi recuperate.

Eroarea, în practică:AggregateException: One or more errors occurred.

89 Mid

Cum pui o limită de timp unei operații asincrone? Ce face Task.WhenAny și ce problemă are folosit pentru timeout?

Răspuns scurt: Task.WhenAny întoarce prima sarcină terminată, deci poți compara operația cu un Task.Delay. Dar operația pierzătoare continuă să ruleze. Varianta modernă este WaitAsync(timeout) (.NET 6) pentru așteptare, iar pentru oprirea reală transmiți un CancellationToken cu timeout.

Varianta clasică, cu WhenAny:

C#
var operatie = client.GetStringAsync(url);
var castigator = await Task.WhenAny(operatie, Task.Delay(TimeSpan.FromSeconds(3)));

if (castigator == operatie)
    Console.WriteLine(await operatie);   // rezultatul sau excepția operației
else
    Console.WriteLine("Timeout");

WhenAny întoarce un Task<Task>: sarcina care s-a terminat prima. Nu aruncă excepție dacă sarcina câștigătoare a eșuat; de aceea faci await operatie ca să obții rezultatul sau excepția.

Problema: la timeout, operatie nu se oprește. Cererea HTTP continuă, consumă o conexiune și eventual termină mai târziu, iar o excepție a ei rămâne neobservată. Dacă faci asta în buclă, acumulezi operații orfane.

Din .NET 6, WaitAsync face aceeași așteptare mai simplu:

C#
try
{
    string html = await client.GetStringAsync(url).WaitAsync(TimeSpan.FromSeconds(3));
}
catch (TimeoutException)
{
    Console.WriteLine("Timeout");
}

Dar are aceeași limită: renunță la așteptare, nu la operație.

Ca să oprești efectiv lucrul, operația trebuie să accepte anulare:

C#
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(3));
try
{
    string html = await client.GetStringAsync(url, cts.Token);
}
catch (OperationCanceledException) when (cts.IsCancellationRequested)
{
    Console.WriteLine("Timeout: cererea a fost anulată");
}

Aici, la expirare, HttpClient închide efectiv cererea. Pentru HttpClient există și proprietatea Timeout (implicit 100 de secunde), aplicată tuturor cererilor.

WhenAny rămâne util în alte scenarii: interogarea a două servere în paralel și folosirea primului răspuns (cu anularea celuilalt), sau procesarea sarcinilor pe măsură ce se termină.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre a nu mai aștepta și a opri o operație. Majoritatea candidaților nu observă că operația continuă după timeout.

Eroarea, în practică:TaskCanceledException: A task was canceled.

90 Mid

Ce este IAsyncEnumerable<T>? Scrie o metodă care citește liniile unui fișier mare asincron, una câte una.

Răspuns scurt: IAsyncEnumerable<T> (C# 8) este o secvență ale cărei elemente sosesc asincron. Metoda o produce cu async și yield return, iar consumatorul o parcurge cu await foreach, fără să încarce toate datele în memorie.

Înainte de C# 8 aveai două variante proaste pentru date care sosesc treptat dintr-o sursă lentă: Task<List<T>> (aștepți totul și ții totul în memorie) sau IEnumerable<T> cu operații blocante. IAsyncEnumerable<T> combină iteratorii cu async:

C#
using System.Runtime.CompilerServices;

static async IAsyncEnumerable<string> CitesteLiniiAsync(
    string cale,
    [EnumeratorCancellation] CancellationToken ct = default)
{
    using var cititor = new StreamReader(cale);
    while (await cititor.ReadLineAsync(ct) is { } linie)
        yield return linie;
}

await foreach (var linie in CitesteLiniiAsync("aplicatie.log"))
{
    if (linie.Contains("ERROR"))
        Console.WriteLine(linie);
}

Cum funcționează: la fiecare iterație, await foreach apelează MoveNextAsync(), care rulează metoda până la următorul yield return. Între elemente, firul nu este blocat cât timp se citește de pe disc. În memorie se află doar linia curentă. ReadLineAsync(CancellationToken) există din .NET 7.

Atributul [EnumeratorCancellation] permite transmiterea anulării în ambele feluri: ca parametru direct sau prin .WithCancellation(ct) la consumator:

C#
await foreach (var linie in CitesteLiniiAsync(cale).WithCancellation(ct)) { ... }

Unde îl întâlnești în practică:

  • EF Core: AsAsyncEnumerable() pe o interogare, pentru procesarea rândurilor pe măsură ce sosesc
  • ASP.NET Core: un endpoint care întoarce IAsyncEnumerable<T> trimite JSON-ul în flux
  • Channel<T>.Reader.ReadAllAsync() pentru consumarea unei cozi
  • API-uri de modele AI care trimit răspunsul token cu token

Operatorii LINQ pentru secvențe asincrone (Where, Select pe IAsyncEnumerable<T>) vin din pachetul System.Linq.Async și au fost incluși în biblioteca standard în .NET 10.

Ce urmărește intervievatorul: Verifică familiaritatea cu fluxurile asincrone și cu problema memoriei la date mari. Un candidat bun știe cum se transmite anularea.

91 Mid

Un serviciu trebuie să descarce date de la 500 de URL-uri. Colegul a scris await Task.WhenAll(urls.Select(u => client.GetStringAsync(u))), iar în producție apar timeout-uri și erori de la serverul extern. Ce ai face?

Răspuns scurt: Problema este că toate cele 500 de cereri pornesc simultan. Limitez concurența, de exemplu cu un SemaphoreSlim(10) sau cu Parallel.ForEachAsync cu MaxDegreeOfParallelism, adaug reîncercări cu pauză crescătoare pentru erorile temporare și tratez separat fiecare eșec.

Un răspuns structurat:

Diagnostic. Task.WhenAll peste 500 de sarcini pornește toate cererile aproape în același moment. Serverul extern vede un vârf de trafic și poate răspunde cu 429 (prea multe cereri) sau poate închide conexiuni; local se epuizează conexiunile disponibile, iar cererile din coadă depășesc timeout-ul. În plus, un singur eșec face ca WhenAll să arunce, chiar dacă 499 au reușit.

Limitarea concurenței:

C#
var limitator = new SemaphoreSlim(10);

async Task<string?> DescarcaAsync(string url, CancellationToken ct)
{
    await limitator.WaitAsync(ct);
    try
    {
        return await client.GetStringAsync(url, ct);
    }
    catch (HttpRequestException ex)
    {
        _log.LogWarning(ex, "Eșec la {Url}", url);
        return null;
    }
    finally
    {
        limitator.Release();
    }
}

var rezultate = await Task.WhenAll(urls.Select(u => DescarcaAsync(u, ct)));

Release stă în finally, ca o excepție să nu blocheze definitiv un loc din semafor. O variantă echivalentă din .NET 6 este Parallel.ForEachAsync(urls, new ParallelOptions { MaxDegreeOfParallelism = 10 }, ...).

Reziliență. Pentru erori temporare (timeout, 503, 429) adaug reîncercări cu pauză exponențială, de exemplu cu biblioteca Polly sau cu Microsoft.Extensions.Http.Resilience, respectând antetul Retry-After dacă serverul îl trimite.

Verificări suplimentare. Un singur HttpClient partajat (sau IHttpClientFactory), nu unul creat per cerere. Valoarea limitei o aleg împreună cu cei care operează serverul extern sau din documentația lor de rate limiting, apoi o fac configurabilă.

De ce nu lock: nu poți folosi await în interiorul unui lock (eroarea CS1996), iar SemaphoreSlim este primitiva potrivită pentru cod asincron.

Ce urmărește intervievatorul: Întrebare de situație care verifică dacă înțelegi concurența fără limită și reziliența. Un răspuns bun tratează și eșecurile individuale.

Eroarea, în practică:SemaphoreFullException: exceeds its maximum count

92 Senior

Ai de procesat 10.000 de fișiere: fiecare trebuie citit de pe disc, transformat printr-un calcul costisitor și trimis la un API. Cum alegi între Task.WhenAll, Parallel.ForEachAsync, Parallel.ForEach și PLINQ?

Răspuns scurt: Parallel.ForEach și PLINQ sunt pentru calcul sincron, Task.WhenAll pentru puține operații I/O, iar Parallel.ForEachAsync pentru lucru asincron cu concurență limitată. Pentru un flux mixt, un pipeline cu Channel<T> permite limite diferite pe fiecare etapă.

Uneltele și ce optimizează fiecare:

  • Parallel.For / Parallel.ForEach: împart lucrul sincron pe firele din pool, aproximativ cât nuclee are mașina. Potrivite pentru calcul pur. Folosite cu I/O blocant, țin firele ocupate în așteptare
  • PLINQ (fisiere.AsParallel().Select(Transforma)): același scop, cu sintaxă LINQ; util pentru transformări și agregări pe date în memorie
  • Task.WhenAll: pornește toate operațiile asincrone deodată, fără nicio limită; bun pentru câteva zeci de cereri independente, periculos pentru 10.000
  • Parallel.ForEachAsync (.NET 6): parcurge o colecție cu un corp async și o limită configurabilă de concurență
C#
await Parallel.ForEachAsync(fisiere,
    new ParallelOptions { MaxDegreeOfParallelism = 8, CancellationToken = ct },
    async (cale, token) =>
    {
        var continut = await File.ReadAllBytesAsync(cale, token);
        var rezultat = Transforma(continut);          // CPU
        await api.TrimiteAsync(rezultat, token);       // rețea
    });

Varianta aceasta e simplă și adesea suficientă. Limita ei: o singură valoare de concurență pentru trei etape cu caracteristici diferite. Calculul vrea cam câte un fir pe nucleu, API-ul poate accepta doar câteva cereri simultane, iar discul are propriile limite.

Pentru control fin, un pipeline cu Channel<T> mărginit: o etapă citește fișiere, mai mulți consumatori fac calculul, alți câțiva trimit la API. Canalele mărginite aplică presiune înapoi (backpressure): dacă API-ul e lent, calculul se oprește când coada e plină, în loc să umple memoria. TPL Dataflow (TransformBlock, ActionBlock) oferă același model gata făcut.

Indiferent de variantă: rezultatele scrise din mai multe fire cer structuri thread-safe sau acumulare locală, erorile individuale se loghează fără să oprească tot lotul, iar progresul se salvează ca procesarea să poată fi reluată.

Ce urmărește intervievatorul: Verifică dacă poți potrivi unealta de concurență cu tipul de lucru. Un senior propune pipeline-uri cu backpressure pentru fluxuri mixte.

Eroarea, în practică:ChannelClosedException: The channel has been closed.

93 Senior

Ai o bibliotecă veche care anunță rezultatul printr-un eveniment (MesajPrimit). Cum o transformi într-o metodă Task<string> AsteaptaMesajAsync()? Ce rol are TaskCompletionSource?

Răspuns scurt: TaskCompletionSource<T> creează un Task pe care îl termini tu manual cu SetResult, SetException sau SetCanceled. Te abonezi la eveniment, iar în handler te dezabonezi și termini task-ul; folosești RunContinuationsAsynchronously și tratezi anularea.

Majoritatea task-urilor sunt create de metode async sau de API-uri I/O. TaskCompletionSource<T> este puntea pentru orice altă sursă de rezultate: evenimente, callback-uri, mesaje de la alt proces.

C#
public static Task<string> AsteaptaMesajAsync(ClientVechi client, CancellationToken ct = default)
{
    var tcs = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);

    void Handler(object? sender, MesajEventArgs e)
    {
        client.MesajPrimit -= Handler;
        tcs.TrySetResult(e.Text);
    }

    client.MesajPrimit += Handler;

    if (ct.CanBeCanceled)
    {
        ct.Register(() =>
        {
            client.MesajPrimit -= Handler;
            tcs.TrySetCanceled(ct);
        });
    }

    return tcs.Task;
}

string mesaj = await AsteaptaMesajAsync(client, cts.Token);

Detaliile importante:

  • dezabonarea în handler și la anulare: altfel handler-ul și tcs rămân referite de client, iar evenimentele ulterioare încearcă să termine un task deja terminat
  • TrySetResult / TrySetCanceled în loc de SetResult: între eveniment și anulare poate exista o cursă; variantele Try nu aruncă dacă task-ul e deja terminat
  • RunContinuationsAsynchronously: implicit, codul de după await poate rula sincron, chiar în interiorul apelului TrySetResult, adică pe firul bibliotecii care a declanșat evenimentul și în timp ce aceasta ține eventual un lock. Asta poate produce blocaje sau reintrări greu de depanat. Opțiunea mută continuările pe thread pool
  • excepțiile se transmit cu TrySetException, dacă biblioteca are un eveniment de eroare

Înregistrarea întoarsă de ct.Register ar trebui eliberată după terminare, într-o implementare de producție, ca să nu țină referințe după ce task-ul s-a încheiat.

Același tipar stă la baza multor primitive asincrone: semafoare, cozi și cereri-răspuns peste conexiuni WebSocket, unde fiecare cerere trimisă are un TaskCompletionSource terminat la sosirea răspunsului cu același identificator.

Ce urmărește intervievatorul: Testează înțelegerea modului în care sunt construite task-urile și a capcanelor de concurență. RunContinuationsAsynchronously este detaliul care distinge un senior.

Eroarea, în practică:InvalidOperationException: task already completed

Memorie și performanță

94 Junior

Un coleg junior nu înțelege de ce prima metodă schimbă soldul, iar a doua nu. Ce afișează codul și cum i-ai explica?

C#
class Cont { public decimal Sold; }

static void Modifica(Cont c) { c.Sold = 100; }
static void Inlocuieste(Cont c) { c = new Cont { Sold = 500 }; }
static void InlocuiesteRef(ref Cont c) { c = new Cont { Sold = 900 }; }

var cont = new Cont();
Modifica(cont);         Console.WriteLine(cont.Sold);
Inlocuieste(cont);      Console.WriteLine(cont.Sold);
InlocuiesteRef(ref cont); Console.WriteLine(cont.Sold);

Răspuns scurt: Afișează 100, 100 și 900. În C#, parametrii se transmit implicit prin valoare: pentru o clasă, valoarea copiată este referința. Metoda poate modifica obiectul referit, dar dacă reatribuie parametrul, schimbă doar copia ei; cu ref schimbă chiar variabila apelantului.

Explicația pe care i-aș da-o colegului, cu o analogie și apoi cu regula exactă.

Analogia: variabila cont nu conține contul, ci adresa lui, ca un bilet pe care scrie „seiful 17”. Când apelezi o metodă, îi dai o fotocopie a biletului.

  • Modifica: cu fotocopia, metoda merge la seiful 17 și schimbă soldul. Apelantul, cu biletul original, vede aceeași schimbare: 100
  • Inlocuieste: metoda își șterge fotocopia și scrie pe ea „seiful 42”, unde pune un cont nou. Biletul apelantului arată tot spre seiful 17: 100
  • InlocuiesteRef: cu ref, metoda primește chiar biletul original, nu o copie; dacă scrie altă adresă pe el, apelantul o vede: 900

Regula precisă: în C#, totul se transmite prin valoare, dacă nu ceri altceva. Pentru tipurile valoare (int, struct) se copiază datele, pentru tipurile referință (class) se copiază referința. A spune că „obiectele se transmit prin referință” este o simplificare care produce exact confuzia colegului. ref, out și in schimbă modul de transmitere, nu tipul.

Cum aș verifica înțelegerea: îi cer să prezică ce se întâmplă dacă Cont devine struct. Răspunsul corect: prima linie afișează 0, pentru că metoda modifică o copie a întregului struct.

Practic, i-aș spune și că ref pe tipuri referință este rar necesar. Dacă o metodă trebuie să producă un obiect nou, e mai clar să-l întoarcă: cont = CreeazaCont();. În code review, reatribuirea unui parametru (ca în Inlocuieste) este aproape mereu un bug sau un cod derutant.

Ce urmărește intervievatorul: Întrebare de situație care verifică atât înțelegerea transmiterii parametrilor, cât și capacitatea de a explica. Un răspuns bun încheie cu o verificare a înțelegerii.

Eroarea, în practică:CS1620: Argument must be passed with 'ref'

95 Junior

Ce face GC.Collect() și de ce nu ar trebui să-l apelezi în codul obișnuit?

Răspuns scurt: Forțează o colectare completă a memoriei, care oprește aplicația și promovează obiectele încă vii în generațiile superioare, ceea ce poate înrăutăți performanța. Garbage collector-ul decide singur, pe baza alocărilor, când să ruleze; apelul manual are sens doar în teste, benchmark-uri sau cazuri rare, măsurate.

Garbage collector-ul (GC) din .NET este proiectat să decidă singur momentul colectării. Pornește când alocările depășesc anumite praguri, când sistemul are puțină memorie sau când e apelat explicit.

Ce se întâmplă la GC.Collect():

  • se face o colectare completă, a tuturor generațiilor, mult mai costisitoare decât colectările obișnuite ale generației 0
  • firele aplicației pot fi oprite pe durata unor etape ale colectării
  • obiectele încă vii sunt promovate în generațiile superioare; obiecte cu viață scurtă care ar fi murit ieftin în generația 0 ajung în generația 2, unde vor fi colectate mai rar și mai scump
  • euristicile GC-ului pierd informația despre ritmul real al alocărilor

De aceea apelul manual face de obicei aplicația mai lentă, nu mai eficientă. Și nu rezolvă scurgerile de memorie: un obiect încă referit (de exemplu dintr-o listă statică sau dintr-un eveniment) nu va fi colectat oricât de des chemi GC-ul.

GC.Collect() nu eliberează nici resursele negestionate (fișiere, conexiuni, handle-uri); pentru ele există Dispose și using. Să aștepți GC-ul ca să închidă un fișier este un bug.

Unde are sens:

  • teste care verifică că un obiect a fost colectat (de exemplu cu WeakReference)
  • foarte rar, după o operație unică ce a creat mulți obiecte temporare, într-o aplicație desktop, înaintea unei perioade de inactivitate, și doar dacă măsurătorile arată un câștig

Pentru a înțelege consumul de memorie, folosești unelte, nu apeluri manuale: dotnet-counters pentru dimensiunea heap-ului și frecvența colectărilor, dotnet-gcdump sau un profiler pentru a vedea ce obiecte ocupă memoria.

Ce urmărește intervievatorul: Verifică înțelegerea rolului GC-ului și a diferenței dintre memoria gestionată și resurse. Mulți juniori cred că GC.Collect() rezolvă probleme de memorie.

96 Mid

Unde are loc boxing în codul următor?

C#
int n = 42;
object o = n;
string s1 = string.Format("{0} bucăți", n);
string s2 = $"{n} bucăți";
IComparable c = n;
var lista = new List<object> { 1, 2, 3 };
var lista2 = new List<int> { 1, 2, 3 };

Răspuns scurt: Boxing apare la object o = n, la string.Format (parametrul e object), la atribuirea către interfața IComparable și la fiecare element din List<object>. Interpolarea din C# 10 și List<int> nu împachetează.

Boxing înseamnă crearea unui obiect pe heap care conține o copie a unei valori de tip valoare, ca acea valoare să poată fi tratată ca object sau ca interfață. Fiecare boxing este o alocare, iar despachetarea (unboxing) cere un cast și o copiere înapoi.

Linie cu linie:

  • object o = n;: boxing explicit
  • string.Format("{0} bucăți", n): supraîncărcarea folosită primește object, deci n este împachetat
  • $"{n} bucăți": din C# 10, compilatorul folosește DefaultInterpolatedStringHandler, cu o metodă generică AppendFormatted<T>(T value), deci fără boxing. Înainte de C# 10, interpolarea devenea string.Format și împacheta
  • IComparable c = n;: conversia unui tip valoare la o interfață creează o cutie
  • List<object> { 1, 2, 3 }: trei alocări, câte una pentru fiecare număr
  • List<int>: valorile stau direct în tabloul intern int[], fără boxing

Alte locuri unde boxing-ul apare fără să-l vezi:

  • un struct transmis unei metode care primește o interfață (void Afiseaza(IFormattable f)), spre deosebire de o metodă generică constrânsă (void Afiseaza<T>(T f) where T : IFormattable), care nu împachetează
  • un struct folosit drept cheie de dicționar fără IEquatable<T>
  • Enum.HasFlag în versiuni vechi de .NET (în .NET Core 2.1+, JIT-ul îl optimizează)
  • colecții vechi, negenerice (ArrayList, Hashtable)

Contează când apare într-o buclă fierbinte: milioane de alocări mici cresc presiunea pe GC și consumul de procesor. Într-un cod obișnuit, un boxing ocazional e irelevant. Locurile reale le găsești cu un profiler de alocări (vizualizarea „Allocations” în Visual Studio sau dotMemory, sau dotnet-trace), unde apar ca alocări de tipul System.Int32 sau ale struct-ului tău.

Ce urmărește intervievatorul: Verifică dacă recunoști boxing-ul în cod real, nu doar în exemplul cu object. Detaliul despre interpolarea din C# 10 arată cunoașterea limbajului modern.

97 Mid

Un coleg propune să rescrie toate concatenările de string-uri din proiect cu StringBuilder, „pentru performanță”. Cum ai evalua propunerea?

Răspuns scurt: Aș cere măsurători, pentru că regula e doar parțial adevărată: concatenările dintr-o singură expresie și interpolarea sunt deja eficiente, iar StringBuilder câștigă clar doar în bucle cu număr necunoscut de pași. Aș propune schimbarea doar în locurile dovedite problematice, cu un benchmark.

Un răspuns structurat:

Ce e adevărat în propunere. String-urile sunt imutabile, deci s += x într-o buclă creează la fiecare pas un string nou și copiază tot conținutul anterior. Pentru n pași, costul crește pătratic. Aici StringBuilder, care scrie într-un buffer extensibil, este alegerea corectă.

Ce nu e adevărat. Multe concatenări sunt deja optime:

  • a + " " + b + " " + c într-o singură expresie se compilează într-un singur apel string.Concat, cu o singură alocare
  • interpolarea ($"{nume} are {varsta} ani") folosește din C# 10 un handler care construiește direct rezultatul
  • pentru colecții există string.Join, care calculează lungimea totală și alocă o dată

Înlocuirea acestora cu StringBuilder face codul mai lung și uneori chiar mai lent, prin alocarea builder-ului.

Cum decid. Propun un benchmark pe cazurile reale:

C#
[MemoryDiagnoser]
public class ConcatBench
{
    private readonly string[] _cuvinte = Enumerable.Range(0, 1000).Select(i => i.ToString()).ToArray();

    [Benchmark] public string Plus() { var s = ""; foreach (var c in _cuvinte) s += c; return s; }
    [Benchmark] public string Builder() { var sb = new StringBuilder(); foreach (var c in _cuvinte) sb.Append(c); return sb.ToString(); }
    [Benchmark] public string Join() => string.Join("", _cuvinte);
}

Apoi verific cu un profiler unde se alocă efectiv memorie în aplicație. De obicei, câteva locuri (generarea de rapoarte, exporturi, loguri în bucle) contează, iar restul nu.

Cum discut. Apreciez preocuparea pentru performanță, arăt rezultatele și propun o regulă simplă pentru echipă: StringBuilder sau string.Join în bucle, interpolare în rest.

Ce urmărește intervievatorul: Întrebare de situație care verifică dacă deciziile de performanță se bazează pe măsurători. Un răspuns bun nu respinge propunerea, ci o rafinează.

98 Mid

Ce face Lazy<T>? Cum implementezi o inițializare costisitoare care să ruleze o singură dată, chiar dacă mai multe fire o cer simultan?

Răspuns scurt: Lazy<T> amână crearea unei valori până la primul acces la .Value și, în modul implicit, garantează că fabrica rulează o singură dată, chiar cu acces concurent. Este varianta simplă și corectă față de verificările manuale cu lock.

Inițializarea leneșă are sens când o valoare e costisitoare (citirea unui fișier mare, o conexiune, un cache încărcat din baza de date) și poate să nu fie folosită deloc.

C#
public class CatalogProduse
{
    private readonly Lazy<Dictionary<string, Produs>> _produse =
        new(() => IncarcaDinFisier("produse.json"));

    public Produs? Cauta(string cod) =>
        _produse.Value.GetValueOrDefault(cod);   // încărcare la primul apel

    private static Dictionary<string, Produs> IncarcaDinFisier(string cale)
    {
        Console.WriteLine("Încarc catalogul...");
        // citire și parsare
        return new Dictionary<string, Produs>();
    }
}

Modurile de siguranță între fire (LazyThreadSafetyMode):

  • ExecutionAndPublication (implicit): un singur fir rulează fabrica, celelalte așteaptă rezultatul
  • PublicationOnly: mai multe fire pot rula fabrica simultan, dar doar primul rezultat este păstrat; potrivit când fabrica e ieftină și nu are efecte secundare
  • None: fără sincronizare, doar pentru cod cu un singur fir

O capcană: în modul implicit, dacă fabrica aruncă o excepție, Lazy o memorează, iar orice acces ulterior la .Value aruncă aceeași excepție, fără să mai încerce. Pentru o eroare temporară (rețea), asta blochează definitiv valoarea; în acest caz folosești PublicationOnly (care nu memorează excepțiile) sau o logică proprie de reîncercare.

Alternative:

  • un câmp static readonly inițializat la declarare: runtime-ul garantează inițializarea o singură dată, thread-safe, la prima utilizare a tipului; pentru singleton-uri simple e suficient
  • LazyInitializer.EnsureInitialized(ref _camp, () => ...): aceeași idee fără obiectul Lazy
  • varianta manuală cu dublă verificare și lock este ușor de greșit (lipsa lui volatile, ordinea scrierilor) și nu aduce nimic față de Lazy<T>

Pentru valori asincrone, Lazy<Task<T>> funcționează: await _date.Value pornește încărcarea o singură dată, iar toți apelanții așteaptă același task.

Ce urmărește intervievatorul: Verifică dacă știi unealta standard pentru inițializare concurentă și comportamentul ei la erori. Mulți candidați scriu un double-checked locking greșit.

99 Senior

Scrie o metodă care extrage anul, luna și ziua dintr-un text de forma „2026-10-31” fără să aloce string-uri intermediare. Ce restricții are Span<T>?

Răspuns scurt: Primești un ReadOnlySpan<char>, iei bucățile cu Slice și le parsezi direct cu int.Parse(ReadOnlySpan<char>), fără Substring. Span<T> este un ref struct: trăiește doar pe stivă, deci nu poate fi câmp într-o clasă, nu poate fi capturat într-o lambda și nu poate fi folosit peste un await.

Varianta clasică, text.Substring(0, 4), creează un string nou pentru fiecare bucată. Cu ReadOnlySpan<char> lucrezi direct pe memoria textului original:

C#
static (int An, int Luna, int Zi) ParseazaData(ReadOnlySpan<char> text)
{
    if (text.Length != 10 || text[4] != '-' || text[7] != '-')
        throw new FormatException("Formatul așteptat este yyyy-MM-dd");

    int an = int.Parse(text[..4]);
    int luna = int.Parse(text.Slice(5, 2));
    int zi = int.Parse(text.Slice(8, 2));
    return (an, luna, zi);
}

var (a, l, z) = ParseazaData("2026-10-31");   // string se convertește implicit la ReadOnlySpan<char>

Un Span<T> este o „fereastră” peste o zonă de memorie continuă: un tablou, un string, memorie de pe stivă sau memorie negestionată. Slice doar creează o fereastră nouă, fără copiere.

Pentru buffere mici și temporare, poți aloca direct pe stivă:

C#
Span<byte> buffer = stackalloc byte[256];

Restricțiile vin din faptul că Span<T> este un ref struct și poate referi memorie de pe stivă, care dispare la ieșirea din metodă. Compilatorul impune ca el să nu ajungă niciodată pe heap:

  • nu poate fi câmp într-o clasă sau într-un struct obișnuit
  • nu poate fi împachetat (boxing) sau convertit la object ori la interfață
  • nu poate fi capturat de lambda sau de funcții locale convertite la delegați
  • nu poate fi folosit în metode async peste un await și nici în iteratori peste un yield (C# 13 permite variabile ref struct în aceste metode, dar tot nu peste un await sau yield)

Când ai nevoie să păstrezi o astfel de fereastră pe heap sau peste await, folosești Memory<T> / ReadOnlyMemory<T>, iar la momentul procesării obții .Span.

Ce urmărește intervievatorul: Verifică dacă poți folosi Span<T> concret, nu doar defini. Un senior explică restricțiile prin motivul lor: memoria de pe stivă.

100 Senior

Un serviciu de procesare a fișierelor alocă un byte[] de 64 KB pentru fiecare cerere și are pauze frecvente de garbage collection. Cum ai reduce alocările?

Răspuns scurt: Reutilizezi bufferele cu ArrayPool<byte>.Shared: Rent la începutul operației, Return într-un finally, ținând cont că tabloul primit poate fi mai mare decât ai cerut. Bufferele de peste 85.000 de octeți ajung altfel pe Large Object Heap, colectat doar cu generația 2.

Problema are două componente. Fiecare cerere alocă un tablou nou, deci la trafic mare GC-ul rulează des. Iar tablourile de cel puțin 85.000 de octeți sunt alocate pe Large Object Heap (LOH), colectat doar odată cu generația 2, cea mai costisitoare colectare. Chiar sub acest prag, alocarea repetată a unei memorii care poate fi reutilizată este risipă.

ArrayPool<T> păstrează tablouri pentru reutilizare:

C#
public async Task ProceseazaAsync(Stream sursa, CancellationToken ct)
{
    const int Marime = 64 * 1024;
    byte[] buffer = ArrayPool<byte>.Shared.Rent(Marime);
    try
    {
        int citit;
        while ((citit = await sursa.ReadAsync(buffer.AsMemory(0, Marime), ct)) > 0)
        {
            ProceseazaBucata(buffer.AsSpan(0, citit));
        }
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(buffer);
    }
}

Reguli de folosire corectă:

  • Rent poate întoarce un tablou mai mare decât ai cerut; folosești mereu lungimea ta (Marime, citit), nu buffer.Length
  • tabloul primit nu este golit și poate conține date de la utilizatorul anterior; pentru date sensibile, Return(buffer, clearArray: true)
  • după Return, nu mai folosești tabloul: îl poate primi deja altcineva, iar bug-ul rezultat (două operații care scriu în același buffer) e greu de găsit
  • Return în finally, ca o excepție să nu piardă tabloul (nu e o scurgere gravă, dar reduce beneficiul)

Alte unelte din aceeași familie:

  • ObjectPool<T> (Microsoft.Extensions.ObjectPool) pentru obiecte costisitoare, de exemplu StringBuilder-e
  • System.IO.Pipelines, care gestionează intern buffere din pool pentru procesarea de fluxuri

Procesul rămâne cel de la orice optimizare: confirm ipoteza cu dotnet-counters (frecvența colectărilor pe generații, dimensiunea LOH) sau cu un profiler de alocări, aplic schimbarea, apoi măsor din nou sub o sarcină comparabilă.

Ce urmărește intervievatorul: Verifică experiența cu optimizarea memoriei în servicii reale. Regulile de utilizare corectă a pool-ului contează mai mult decât știrea că există.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de C#, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață C# scriind cod, nu doar citind

Curs C#: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.