var și tipurile de date (int, decimal, bool) în C# (.NET): sintaxă, parametri și exemple practice

Ce face `var și tipurile de date (int, decimal, bool)`

C# este un limbaj cu tipizare statică puternică: fiecare variabilă și expresie are un tip cunoscut la momentul compilării. Cuvântul cheie var (introdus în C# 3.0 pentru variabile locale) nu înseamnă tipizare dinamică (precum în JavaScript sau dynamic), ci îi cere compilatorului să deducă automat tipul exact din expresia aflată în dreapta semnului =. De exemplu, var contor = 0; este 100% identic în codul compilat (IL) cu int contor = 0;.

Sistemul de tipuri din .NET împarte datele în tipuri valoare (stocate direct pe stivă sau inline în structuri: int, long, double, decimal, bool, char, DateTime, struct) și tipuri referință (alocate pe heap și gestionate de Garbage Collector: string, object, class, record, tablouri). Pentru calcule financiare, prețuri și taxe se folosește obligatoriu tipul decimal (pe 128 de biți, în bază 10, cu sufixul m), evitând erorile de rotunjire binară specifice tipurilor double și float.

Parametri, metode și opțiuni

Parametru / Metodă	Descriere
`int / long`	Numere întregi cu semn pe 32 de biți (`int`, până la ~2,14 miliarde) și 64 de biți (`long`, sufix `L`).
`double / float`	Numere în virgulă mobilă binară IEEE 754 pe 64 de biți (`double`) sau 32 de biți (`float`, sufix `f`) pentru calcule științifice și grafică.
`decimal`	Număr zecimal de înaltă precizie (128 biți, 28-29 cifre semnificative, sufix `m`), obligatoriu pentru sume bănești și contabilitate.
`bool / char / string`	Valori logice (`true` / `false`), un caracter Unicode UTF-16 (`'a'`) și șiruri imutabile de caractere (`"text"`).
`var`	Inferență de tip la compilare pentru variabile locale; necesită inițializare imediată în aceeași instrucțiune.
`new()`	Instanțiere target-typed (C# 9+): când tipul este deja scris în stânga (ex. `List<string> lista = new();`), nu mai trebuie repetat după `new`.

Exemple

Exemplul 1: Diferența dintre double și decimal în calcule financiare

În baza 2 (double), fracții precum 0.1 și 0.2 nu au reprezentare finită exactă. Cu decimal (sufixul m), calculele financiare sunt exacte la nivel de cent.

double d1 = 0.1;
double d2 = 0.2;
Console.WriteLine($"double:  0.1 + 0.2 == 0.3 -> {(d1 + d2 == 0.3)} (suma este {d1 + d2:G17})");

decimal m1 = 0.1m;
decimal m2 = 0.2m;
Console.WriteLine($"decimal: 0.1m + 0.2m == 0.3m -> {(m1 + m2 == 0.3m)} (suma este {m1 + m2})");

// Separatori vizuali '_' (C# 7+) pentru lizibilitate în numere mari:
long bugetAnual = 14_500_000L;
var rataTva = 0.19m; // compilatorul deduce automat tipul 'decimal'
Console.WriteLine($"TVA calculat: {bugetAnual * rataTva:N2} RON");

Ieșire în consolă

double:  0.1 + 0.2 == 0.3 -> False (suma este 0.30000000000000004)
decimal: 0.1m + 0.2m == 0.3m -> True (suma este 0.3)
TVA calculat: 2,755,000.00 RON

Exemplul 2: Utilizarea corectă a inferenței de tip cu var și tupluri

var elimină redundanța vizuală mai ales la tipuri generice lungi sau la deconstrucția tuplurilor, păstrând verificarea strictă a tipurilor la compilare.

var (codStatus, mesaj, durataMs) = (200, "OK", 14.8);
Console.WriteLine($"Status {codStatus} ({mesaj}) în {durataMs} ms");

// Verificăm tipurile deduse de compilator la rulare:
Console.WriteLine($"Tipuri: {codStatus.GetType().Name}, {mesaj.GetType().Name}, {durataMs.GetType().Name}");