Stałe i słowo kluczowe var

1. Stałe

Stała — to taka "magiczna" zmienna, której wartości nie można (i nie trzeba!) zmieniać po zadeklarowaniu. Wyobraź sobie superprzylepną naklejkę na swoim kubku z napisem "Tylko herbata". Jak już ją przykleisz, nie zamienisz herbaty na kawę (przynajmniej w ramach C#).

const int DaysInWeek = 7;
const string HelloMessage = "Witamy!";

W tych przykładach DaysInWeek zawsze będzie 7, a HelloMessage — niezmiennie powitalna. Jak tylko wartość stałej zostanie ustalona, nie można jej już zmienić.

Po co są stałe?

• Czytelność kodu: kiedy widzisz const double Pi = 3.14159;, nie masz wątpliwości, że to stała, a nie zmienna, którą ktoś może zmienić w środku programu.
• Bezpieczeństwo: nikt (nawet Ty sam za parę miesięcy) nie nadpisze przypadkiem wartości stałej.
• Wydajność: kompilator C# wstawia wartość stałej bezpośrednio w miejsca użycia, więc program działa trochę szybciej.

Składnia deklaracji

const typ nazwa = wartość;

• Typ — dowolny typ prymitywny (int, double, string, char, a także enumy i literały).
• Nazwa — zwykle używa się stylu CamelCase lub PascalCase. Dla "magicznych" stałych czasem używa się wielkich liter i podkreśleń (DAYS_IN_WEEK), ale w C# nie jest to obowiązkowe.

Przykłady:

const double GRAVITY = 9.81; // przyspieszenie ziemskie, m/s^2
const char DELIMITER = ',';
const string DEVELOPER_NAME = "Jan Kowalski";

Cechy i ograniczenia stałych

• Wartość musi być znana w czasie kompilacji. To znaczy, że nie można zadeklarować stałej, której wartość jest wyliczana podczas działania programu.

const int NowYear = DateTime.Now.Year; // BŁĄD KOMPILACJI!

• Można używać tylko prostych typów, string lub enumów.
• Nie można zrobić stałą z tablicy, obiektu, wyniku wywołania metody itd.
• Nawet wyrażenia, które matematycznie wydają się "proste", muszą być policzone przez kompilator, a nie podczas działania programu.

Na przykład tak nie można:

const string FullGreeting = "Cześć, " + userName; // userName — to zmienna, tak nie można!

A tak — można i warto:

const string DefaultGreeting = "Cześć, użytkowniku!";

Gdzie zwykle deklaruje się stałe?

• Na początku klasy (lub pliku), nad metodami.
• W specjalnych klasach ze stałymi (np. public static class Constants).
• Na poziomie klasy, jeśli stała dotyczy tylko tej klasy.

Przykład dla naszej aplikacji konsolowej:

class Program
{
    const string Welcome = "Witamy w naszej aplikacji!";
    static void Main(string[] args)
    {
        Console.WriteLine(Welcome);
    }
}

Stałe a zakres widoczności

Stałe podlegają tym samym zasadom zakresu widoczności co zwykłe zmienne: są widoczne tylko tam, gdzie zostały zadeklarowane.

2. Słowo kluczowe var

Słowo kluczowe var — to nie jest nowy typ zmiennej, tylko wygodny sposób, żeby kompilator sam wywnioskował typ zmiennej z kontekstu.

To czysty syntactic sugar — żadnej magii, po kompilacji zmienna staje się zwykłego typu.

var age = 23;      // kompilator rozumie: age — to int
var name = "Anna"; // kompilator rozumie: string
var price = 99.99; // kompilator rozumie: double

Dlaczego pojawił się var?

• Czytelność: nie trzeba pisać długich typów (jak Dictionary<string, List<int>>) ręcznie.
• Elastyczność: łatwiej zmieniać typy w przyszłości: poprawiasz po prawej — po lewej var już się dostosuje.
• Nowoczesny styl: praktycznie wszystkie współczesne projekty C# używają var tam, gdzie typ łatwo odczytać z inicjalizacji.

Kiedy można (i warto) używać var

• Kiedy po prawej stronie jednoznacznie widać, jaki typ ma zmienna.
• Kiedy typ jest oczywisty (var price = 100; — wiadomo, że to int).
• Kiedy typ jest bardzo długi lub skomplikowany (np. wynik zapytania LINQ).

var numbers = new int[] { 1, 2, 3, 4 };
var input = Console.ReadLine(); // input — to string (metoda zwraca string)

Kiedy lepiej NIE używać var

Jeśli typ nie jest oczywisty po prawej stronie, kod może być mniej czytelny. I jeśli za miesiąc nawet z pomocą kolegów nie ogarniesz, co to za typ, lepiej napisać go jawnie.

var mystery = DoSomethingVeryComplicated(); // KIM JESTEŚ, mystery???

Tutaj lepiej jawnie podać typ:

string result = DoSomethingVeryComplicated();

Złota zasada: używaj var tylko tam, gdzie nie pogarsza to czytelności!

var — tylko dla zmiennych lokalnych

Słowo kluczowe var działa tylko dla zmiennych lokalnych — wewnątrz metod. Nie można używać var dla:

• parametrów metody;
• właściwości klasy;
• stałych.

Jak działa var "pod maską"

• Kompilator C# podczas kompilacji podstawia właściwy typ.
• Po kompilacji nie ma już żadnego var.
• Nie ma żadnej straty wydajności: to tylko wygoda dla programisty.

var year = 2025; // na etapie kompilacji staje się: int year = 2025;

Typowe błędy przy użyciu var

• Niezaiznicializowana zmienna:

var a; // BŁĄD: Kompilator nie wie, jaki typ wywnioskować!

• Niejasna inicjalizacja:

var list = null; // BŁĄD: Typ null nie jest określony!

• Ponowne użycie zmiennej z różnymi typami:

var value = 5; // value — int
value = "Pięć"; // BŁĄD: value już jest int!

Porównanie: jawne typy i var

int age = 42;

var age = 42;

Dictionary<int, string> dict = SomeFunc();

var dict = SomeFunc();

string[] names = ...

var names = ...

3. Pułapki i porady

W C# często pisze się magiczne liczby wprost w kodzie ("7", "3.14159", "0.15" i inne tajemnicze cyfry). To słabe: jeśli nagle wartość się zmieni, trzeba szukać wszystkich wystąpień w całym projekcie. Używaj stałych! I Tobie będzie łatwiej, i koledzy nie będą kląć...

Z var jest odwrotna skrajność: jeśli cały kod to jeden wielki var, ale nigdzie nie widać, jakie typy są używane — kod szybko robi się nieczytelny. Dlatego używaj var tam, gdzie to logiczne i jasne z kontekstu, a w innych przypadkach nie bój się jawnie podać typu.