Hogyan deklarálsz változókat és hogyan használod a var-t?

Question

Accepted Answer

A C# statikus típusrendszerrel rendelkezik — a változók típusa compile időben ismert. Egy változót deklarálhatsz explicit típussal vagy használhatod a **`var`**-t típus-leveztetéshez (a compiler levezeti a típust az értékből), de mindkét esetben a típus rögzített. ## Változók deklarálása ```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 ``` A `var` levezeti a típust az inicializálóból — `var age = 30` pontosan ugyanaz, mint `int age = 30`. Döntően, **a `var` még mindig statikus típusú**: a típus compile időben rögzített (később nem tudsz string-et hozzárendelni az `age`-hez); csupán levezetetett, nem dinamikus. ## var megköveteli az inicializálót és megtartja a típust rögzítettnek ```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 ``` ## Mikor használd a var-t (stílus) ```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 ``` Használd a `var`-t, ha a típus nyilvánvaló a jobb oldalról (csökkenti az redundanciát, különösen hosszú generikus típusoknál); használj explicit típusokat, ha az segít az érthetőségben. ## Konstansok és egyéb deklarációk ```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 ``` ## Gyakori beépített típusok ```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 ``` ## Miért fontos A változó-deklaráció és a `var` megértése alapvető napi C# ismeret. A fő koncepcionális pont, hogy **a `var` típus-leveztetés, nem dinamikus típusozás** — ez egy gyakori félreértés. A `var`-ral a compiler levezeti a típust az inicializálóból, de a típus még mindig compile időben rögzített (megkapod a statikus típusozás összes előnyét — típus-ellenőrzést, IntelliSense-t, teljesítményt), csak anélkül, hogy explicit módon írnád ki a típust. Ez a `var`-t kényelmi megoldássá teszi az olvashatóságért (különösen hosszú generikus típusoknál, mint `Dictionary>`) ahelyett, hogy a típusrendszert enyhítené. Annak tudása, hogy mikor használd a `var`-t (amikor a típus nyilvánvaló a jobb oldalról, csökkentve az redundanciát) szemben az explicit típusokkal (amikor az segít az érthetőségben), valamint a beépített típusok (nevezetesen a **`decimal` pénzhez** — pontos tizedes számtan, a `double`-tól eltérően), konstansok (`const`, `readonly`), napi ismeret a C# írásához. Annak megértése, hogy a C# végig statikus típusú (akár írod a típust, akár `var`-t használsz), valamint a változó-deklaráció körüli idiómák, alapvető a tiszta, helyes C# kód olvasásához és írásához, és a `var`-nem-dinamikus pont egy gyakori tisztázás, amely a nyelvről való megfelelő megértést tükrözi.