Jak deklarujesz zmienne i używasz var?

Question

Accepted Answer

C# jest językiem ze statycznym typowaniem — zmienne mają typ znany w czasie kompilacji. Możesz deklarować zmienną z jawnym typem lub użyć **`var`** do wnioskowania typu (kompilator dedukuje typ z wartości), ale w każdym przypadku typ jest ustalony. ## Deklarowanie zmiennych ```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` wnioskuje typ z inicjalizatora — `var age = 30` to dokładnie to samo co `int age = 30`. Kluczowe jest, że **`var` jest nadal statycznie typowane**: typ jest ustalony w czasie kompilacji (nie możesz później przypisać string'a do `age`); jest on jedynie wnioskowany, nie dynamiczny. ## var wymaga inicjalizatora i utrzymuje typ ustalony ```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 ``` ## Kiedy używać 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 ``` Używaj `var` gdy typ jest oczywisty z prawej strony (zmniejsza redundancję, zwłaszcza przy długich typach generycznych); używaj jawnych typów gdy poprawia to czytelność. ## Stałe i inne deklaracje ```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 ``` ## Typowe wbudowane 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 ``` ## Dlaczego to ważne Rozumienie deklaracji zmiennych i `var` to fundamentalna, codzienna wiedza z C#. Kluczową ideą jest to, że **`var` to wnioskowanie typu, a nie typowanie dynamiczne** — częste błędne przekonanie. Z `var`, kompilator dedukuje typ z inicjalizatora, ale typ jest nadal ustalony w czasie kompilacji (uzyskujesz wszystkie korzyści ze statycznego typowania — sprawdzanie typów, IntelliSense, wydajność), po prostu bez jawnego napisania nazwy typu. To czyni `var` wygodą dla czytelności (zwłaszcza przy rozwlekłych typach generycznych jak `Dictionary>`) raczej niż osłabieniem systemu typów. Wiedzenie kiedy używać `var` (gdy typ jest oczywisty z prawej strony, zmniejszając redundancję) w stosunku do typów jawnych (gdy poprawia czytelność), wraz z typami wbudowanymi (zwłaszcza **`decimal` do pieniędzy** — dokładna arytmetyka dziesiętna, w przeciwieństwie do `double`), stałymi (`const`, `readonly`), to codzienną wiedzę dla pisania C#. Rozumienie, że C# jest językiem ze statycznym typowaniem wszędzie (niezależnie czy napiszesz typ czy użyjesz `var`), i idiomy wokół deklaracji zmiennych, to fundamentalna wiedza dla czytania i pisania czystego, poprawnego kodu C#, a punkt o tym że `var` to nie dynamika jest częstym wyjaśnieniem, które odzwierciedla właściwe zrozumienie języka.