C# är statiskt typat — variabler har en typ som är känd vid kompileringstidpunkten. Du kan deklarera en variabel med en explicit typ eller använd var för typinferens (kompilatorn härleder typen från värdet), men på båda sätten är typen fixerad.
count = ;
name = ;
price = ;
active = ;
age = ;
message = ;
items = List<>();
var härleder typen från initieraren — var age = 30 är exakt detsamma som int age = 30. Avgörande är att var fortfarande är statiskt typat: typen är fixerad vid kompileringstidpunkten (du kan senare inte tilldela en sträng till age); det är bara härledd, inte dynamisk.
var x = 5;
x = "hi"; // ❌ compile error — x is an int, can't become a string
var y; // ❌ error — var needs an initializer to infer from
var user = new UserService(); // ✅ type is obvious from the right side — var is clean
var count = users.Count;
int total = CalculateComplexValue(); // explicit when the type isn't obvious aids readability
Använd var när typen är uppenbar från höger sida (minskar redundans, särskilt med långa generiska typer); använd explicita typer när det förbättrar tydligheten.
const double Pi = 3.14159; // compile-time constant (can't change)
readonly int id; // set once (in constructor), then immutable
int a = 1, b = 2; // multiple of the same type
nint nativeInt; // platform-sized integer
int, long, short, byte integers
float, double, decimal floating point (decimal for money — exact)
bool, char, string boolean, character, text
object the base of all types
Att förstå variabeldeklaration och var är grundläggande vardaglig C#-kunskap.
Den viktigaste konceptuella punkten är att var är typinferens, inte dynamisk typning — ett vanligt missförstånd.
Med var härleder kompilatorn typen från initieraren, men typen är fortfarande fixerad vid kompileringstidpunkten (du får alla fördelar med statisk typning — typleverans, IntelliSense, prestanda), bara utan att skriva typnamnet explicit.
Detta gör var till en bekvämlighet för läsbarhet (särskilt med verbose generiska typer som Dictionary<string, List<int>>) snarare än en lösning av typsystemet.
Att veta när man ska använda var (när typen är uppenbar från höger sida, vilket minskar redundans) kontra explicita typer (när det förbättrar tydligheten), tillsammans med de inbyggda typerna (särskilt decimal för pengar — exakt decimalräkning, till skillnad från double), konstanter (const, readonly), är vardaglig kunskap för att skriva C#.
Att förstå att C# är statiskt typat överallt (oavsett om du skriver typen eller använder var), och idiomen kring variabeldeklaration, är grundläggande för att läsa och skriva ren, korrekt C#-kod, och poängen om att var är inte dynamisk är en vanlig förtydligande som återspeglar rätt förståelse av språket.