Zmienne w C#: var, const, readonly, zakres i nazewnictwo

Zmienna to nazwane miejsce w pamięci o stałym typie. W C# deklarujesz ją typem i nazwą, a opcjonalnie w tej samej instrukcji nadajesz jej wartość. Typ potem się nie zmienia: zmienna int przechowuje liczby całkowite przez cały czas swojego istnienia.

using System;

class Program
{
    static void Main()
    {
        string customer = "Priya";   // declare and initialize
        int quantity;                // declare only
        quantity = 3;                // assign later
        decimal unitPrice = 4.25m;
        bool isMember = true;

        quantity = quantity + 2;     // reassign
        decimal total = quantity * unitPrice;
        if (isMember) total -= 1.00m;

        Console.WriteLine($"{customer} bought {quantity} items for {total:F2}");

        int apples = 4, pears = 6;   // several of the same type
        Console.WriteLine(apples + pears);
    }
}

Wynik:

Priya bought 5 items for 20.25
10

Przypisanie wartości złego typu to błąd kompilacji: quantity = "five"; kończy się błędem CS0029 (cannot implicitly convert type 'string' to 'int'). Konwersja między typami jest jawna; zobacz konwersja typów.

var: wnioskowanie typu przez kompilator

var deklaruje zmienną lokalną, której typ jest wnioskowany z inicjalizatora. To nie jest typowanie dynamiczne: typ jest ustalony w czasie kompilacji, dokładnie tak, jakby był zapisany wprost.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var name = "Oscar";          // string
        var age = 34;                // int
        var price = 19.99m;          // decimal
        var ratio = 0.75;            // double
        var tags = new List<string> { "new", "sale" };

        Console.WriteLine(name.GetType().Name);
        Console.WriteLine(age.GetType().Name);
        Console.WriteLine(price.GetType().Name);
        Console.WriteLine(ratio.GetType().Name);
        Console.WriteLine(tags.GetType().Name);

        // age = "old";  // error CS0029: age is an int, forever
    }
}

Wynik:

String
Int32
Decimal
Double
List`1

var ma trzy zasady. Działa tylko dla zmiennych lokalnych (nie dla pól ani parametrów). Zmienna musi być zainicjalizowana w deklaracji: var x; to błąd CS0818, "Implicitly-typed variables must be initialized". A inicjalizator musi mieć typ: var nothing = null; się nie kompiluje, bo samo null nie ma typu.

Kiedy go używać, to kwestia stylu zespołu. Typowa wskazówka: używaj var, gdy typ jest oczywisty z prawej strony, a zapisuj typ, gdy nie jest:

var orders = new List<Order>();         // obvious: var is fine
var reader = new StreamReader(path);    // obvious
decimal discount = CalculateDiscount(); // not obvious: name the type
int count = items.Count();              // makes the intent clear

Subtelna pułapka: var total = 0; czyni total zmienną typu int, więc późniejsze dodanie do niej 2.5 się nie uda, a var price = 10; to int, a nie decimal. Gdy typ literału nie jest tym, którego chcesz, zapisz typ albo dodaj przyrostek (10m, 0.0).

Zakres

Zmienna lokalna istnieje od deklaracji do końca bloku { }, w którym ją zadeklarowano. Zmienne zadeklarowane w nagłówku pętli albo w ciele if nie są widoczne za nimi.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 82, 91, 67 };
        int sum = 0;                         // visible in the whole of Main

        for (int i = 0; i < scores.Length; i++)   // i: only inside the loop
        {
            int doubled = scores[i] * 2;     // doubled: only inside the loop body
            sum += scores[i];
        }
        // Console.WriteLine(i);        // error CS0103: i does not exist here

        if (sum > 200)
        {
            string label = "high";
            Console.WriteLine(label);
        }
        Console.WriteLine(sum);
    }
}

Wynik:

high
240

W przeciwieństwie do C i C++ C# nie pozwala, żeby blok wewnętrzny zadeklarował zmienną lokalną o tej samej nazwie co zmienna w bloku otaczającym (błąd CS0136): nazwa musi znaczyć jedno w całej metodzie. Dwa sąsiednie bloki mogą użyć tej samej nazwy, tak jak dwie osobne pętle for, z których każda deklaruje i.

Jednoznaczne przypisanie

Zmienne lokalne nie mają wartości domyślnej. Kompilator śledzi każdą ścieżkę w metodzie i odmawia kompilacji, jeśli zmienna może zostać odczytana, zanim zostanie jej przypisana wartość:

int discount;
if (isMember)
{
    discount = 10;
}
Console.WriteLine(discount);
// error CS0165: Use of unassigned local variable 'discount'

Napraw to, inicjalizując zmienną przy deklaracji (int discount = 0;) albo przypisując wartość w każdej gałęzi (dodaj else). Pola i elementy tablic działają inaczej: automatycznie dostają wartość domyślną swojego typu (0, false, null).

const: stałe czasu kompilacji

const to wartość ustalona w czasie kompilacji. Musi być zainicjalizowana wyrażeniem stałym (literałem, inną stałą albo działaniami na nich) i może być tylko liczbą, char, bool, string, enumem albo null.

using System;

class Pricing
{
    public const decimal VatRate = 0.20m;
    public const int MaxItems = 50;
    public const string Currency = "EUR";
    public const string Label = "Price in " + Currency; // consts can combine
}

class Program
{
    static void Main()
    {
        const int Days = 7;          // local constants work too
        decimal net = 100m;

        Console.WriteLine(Pricing.Label);
        Console.WriteLine($"{net * (1 + Pricing.VatRate):F2} {Pricing.Currency}");
        Console.WriteLine(Pricing.MaxItems * Days);
        // Pricing.MaxItems = 60;   // error: cannot assign to a constant
    }
}

Wynik:

Price in EUR
120.00 EUR
350

Pole const jest niejawnie static, więc odwołujesz się do niego przez nazwę typu (Pricing.VatRate), a zapis static const to błąd. Kompilator kopiuje wartość do każdego miejsca, które jej używa, dlatego stałe nic nie kosztują w czasie działania i dlatego publiczna stała w bibliotece powinna być wartością, która nigdy się nie zmieni (jak liczba dni w tygodniu).

readonly i static readonly

Pole readonly można przypisać tylko w jego deklaracji albo w konstruktorze jego klasy. Po utworzeniu obiektu nie może się zmienić. W przeciwieństwie do const jego wartość jest obliczana w czasie działania, może być dowolnego typu i może się różnić między obiektami.

using System;

class Account
{
    public readonly string Id;                    // set once per object
    public readonly DateTime OpenedOn;
    public static readonly DateTime Launch = new DateTime(2020, 1, 15);
    public static readonly string[] Plans = { "free", "pro" };

    public Account(string id, DateTime openedOn)
    {
        Id = id;                                  // allowed: in the constructor
        OpenedOn = openedOn;
    }

    public void Rename(string newId)
    {
        // Id = newId;  // error CS0191: readonly field outside the constructor
    }
}

class Program
{
    static void Main()
    {
        var a = new Account("ACC-17", new DateTime(2024, 5, 2));
        Console.WriteLine($"{a.Id} opened {a.OpenedOn:yyyy-MM-dd}");
        Console.WriteLine($"Launch: {Account.Launch:yyyy-MM-dd}");

        Account.Plans[0] = "basic";   // allowed: the array itself is not readonly
        Console.WriteLine(string.Join(", ", Account.Plans));
    }
}

Wynik:

ACC-17 opened 2024-05-02
Launch: 2020-01-15
basic, pro

Ostatnie linie pokazują częste nieporozumienie: readonly chroni pole, a nie obiekt, na który wskazuje. Plans zawsze będzie odnosić się do tej samej tablicy, ale elementy tablicy nadal mogą się zmieniać. Do naprawdę niemutowalnych kolekcji używaj ReadOnlyCollection<T> albo ImmutableArray<T>.

Podsumowanie trzech wariantów:

Konwencje nazewnictwa

Nazwy w C# rozróżniają wielkość liter (total i Total to różne zmienne) i muszą zaczynać się od litery lub podkreślnika. Konwencje Microsoftu, których przestrzega niemal cały kod C#:

• Zmienne lokalne i parametry: camelCase (orderCount, unitPrice).
• Stałe, właściwości, metody, klasy i pola publiczne: PascalCase (MaxItems, VatRate).
• Pola prywatne: _camelCase z podkreślnikiem na początku (_balance), rozpowszechniona konwencja w kodzie .NET.
• Zmienne logiczne czytają się jak pytania: isActive, hasDiscount, canRetry.
• Unikaj skrótów i przedrostków węgierskich (strName, iCount).

Słowo kluczowe C# nie może być nazwą, chyba że poprzedzisz je znakiem @: var @class = "5B"; jest dozwolone, co czasem przydaje się w kodzie generowanym albo przy nazwach pól JSON.

Zamiana i wielokrotne przypisanie

Od C# 7 krotki pozwalają przypisać kilka zmiennych w jednej instrukcji, co daje zamianę w jednej linii:

using System;

class Program
{
    static void Main()
    {
        int first = 10, second = 20;
        (first, second) = (second, first);
        Console.WriteLine($"{first} {second}");

        var (city, population) = ("Lisbon", 545000);
        Console.WriteLine($"{city}: {population:N0}");
    }
}

Wynik:

20 10
Lisbon: 545,000

Druga forma to dekonstrukcja: z krotki deklaruje city jako string i population jako int. Więcej w krotkach.