Jak deklarujete proměnné a používáte var?

Question

Accepted Answer

C# je staticky typovaný jazyk — proměnné mají typ známý v čase kompilace. Můžete deklarovat proměnnou s explicitním typem nebo použít **`var`** pro odvození typu (kompilátor odvodí typ z hodnoty), ale v obou případech je typ fixní. ## Deklarace proměnných ```csharp int count = 42; // explicit type string name = "Ann"; double price = 9.99; bool active = true; var age = 30; // inferred as int (var = let the compiler figure it out) var message = "Hello"; // inferred as string var items = new List(); // inferred as List ``` `var` odvozuje typ z inicializátoru — `var age = 30` je přesně stejné jako `int age = 30`. Zásadně, **`var` je stále staticky typován**: typ je fixní v čase kompilace (později nemůžete přiřadit řetězec `age`); je jen odvozen, ne dynamický. ## var vyžaduje inicializátor a typu zůstane fixní ```csharp 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 ``` ## Kdy používat var (styl) ```csharp 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 ``` Používejte `var`, když je typ zřejmý z pravé strany (snižuje redundanci, zejména s dlouhými generickými typy); používejte explicitní typy, když to podporuje srozumitelnost. ## Konstanty a další deklarace ```csharp 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 ``` ## Běžné vestavěné typy ```text 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 ``` ## Proč je to důležité Pochopení deklarace proměnných a `var` je základní každodenní znalost C#. Základní koncepční bod je, že **`var` je odvození typu, ne dynamické typování** — běžné nesprávné chápání. S `var` kompilátor odvodí typ z inicializátoru, ale typ je stále fixní v čase kompilace (získáte všechny výhody statického typování — kontrolu typů, IntelliSense, výkon), jen bez explicitního psaní názvu typu. To dělá `var` pohodlím pro čitelnost (zejména s opakujícími se generickými typy jako `Dictionary>`) spíše než uvolňování typového systému. Vědět, kdy používat `var` (když je typ zřejmý z pravé strany, což snižuje redundanci) versus explicitní typy (když to podporuje srozumitelnost), spolu s vestavěnými typy (zejména **`decimal` pro peníze** — přesná desítková aritmetika, na rozdíl od `double`), konstanty (`const`, `readonly`), je každodenní znalost pro psaní C#. Pochopení, že C# je staticky typován vždy (ať už napíšete typ nebo použijete `var`), a idiomy kolem deklarace proměnných, je základní pro čtení a psaní čistého, správného kódu v C#, a bod, že `var` není dynamické, je časté objasnění odrážející správné pochopení jazyka.