Переменные в C#: var, const, readonly, область видимости и имена

Переменная это именованное место хранения с фиксированным типом. В C# её объявляют с типом и именем и при желании сразу задают значение в том же операторе. Тип потом никогда не меняется: переменная int хранит целые числа всё время своего существования.

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);
    }
}

Вывод:

Priya bought 5 items for 20.25
10

Присваивание значения неправильного типа это ошибка компиляции: quantity = "five"; завершается ошибкой CS0029 (cannot implicitly convert type 'string' to 'int'). Преобразование между типами выполняется явно; см. преобразование типов.

var: пусть компилятор выведет тип

var объявляет локальную переменную, тип которой выводится из инициализатора. Это не динамическая типизация: тип фиксируется при компиляции точно так же, как если бы вы написали его сами.

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
    }
}

Вывод:

String
Int32
Decimal
Double
List`1

У var три правила. Он работает только для локальных переменных (не для полей и параметров). Переменная должна быть инициализирована в объявлении: var x; это ошибка CS0818, «Implicitly-typed variables must be initialized». И у инициализатора должен быть тип: var nothing = null; не компилируется, потому что у одиночного null нет типа.

Когда его использовать, решает стиль команды. Обычная рекомендация: использовать var, когда тип очевиден из правой части, и писать тип, когда нет:

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

Тонкая ловушка: var total = 0; делает total переменной типа int, поэтому прибавить к ней потом 2.5 не получится, а var price = 10; это int, а не decimal. Если тип литерала не тот, что вам нужен, напишите тип или добавьте суффикс (10m, 0.0).

Область видимости

Локальная переменная существует от объявления до конца блока { }, в котором она объявлена. Переменные, объявленные в заголовке цикла или в теле if, после них не видны.

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);
    }
}

Вывод:

high
240

В отличие от C и C++, C# не позволяет во внутреннем блоке объявить локальную переменную с тем же именем, что и во внешнем (ошибка CS0136): имя должно означать одно и то же во всём методе. Два соседних блока могут использовать одно имя повторно, как это делают два отдельных цикла for, каждый из которых объявляет i.

Определённое присваивание

У локальных переменных нет значения по умолчанию. Компилятор отслеживает каждый путь выполнения метода и отказывается компилировать код, если переменная может быть прочитана до присваивания:

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

Исправьте это инициализацией при объявлении (int discount = 0;) или присваиванием в каждой ветке (добавьте else). Поля и элементы массивов ведут себя иначе: им автоматически присваивается значение по умолчанию для их типа (0, false, null).

const: константы времени компиляции

const это значение, зафиксированное при компиляции. Его нужно инициализировать константным выражением (литералом, другой константой или арифметикой над ними), и это может быть только число, char, bool, string, перечисление или 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
    }
}

Вывод:

Price in EUR
120.00 EUR
350

Константное поле неявно static, поэтому к нему обращаются через имя типа (Pricing.VatRate), а запись static const это ошибка. Компилятор копирует значение в каждое место использования, поэтому константы ничего не стоят во время выполнения, и поэтому же открытая константа в библиотеке должна быть значением, которое никогда не изменится (например, число дней в неделе).

readonly и static readonly

Поле readonly можно присвоить только в его объявлении или в конструкторе его класса. После создания объекта оно не может измениться. В отличие от const, его значение вычисляется во время выполнения, может быть любого типа и может различаться у разных объектов.

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));
    }
}

Вывод:

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

Последние строки показывают частое заблуждение: readonly защищает поле, а не объект, на который оно ссылается. Plans всегда будет ссылаться на один и тот же массив, но элементы массива по-прежнему можно менять. Для действительно неизменяемых коллекций используйте ReadOnlyCollection<T> или ImmutableArray<T>.

Сводка по всем трём:

Соглашения об именах

Имена в C# чувствительны к регистру (total и Total это разные переменные) и должны начинаться с буквы или подчёркивания. Соглашения Microsoft, которым следует почти весь код на C#:

• Локальные переменные и параметры: camelCase (orderCount, unitPrice).
• Константы, свойства, методы, классы и открытые поля: PascalCase (MaxItems, VatRate).
• Закрытые поля: _camelCase с подчёркиванием в начале (_balance), широко распространённое соглашение в коде .NET.
• Логические переменные читаются как вопросы: isActive, hasDiscount, canRetry.
• Избегайте сокращений и венгерских префиксов (strName, iCount).

Ключевое слово C# нельзя использовать как имя, если не поставить перед ним @: var @class = "5B"; допустимо, что иногда полезно для сгенерированного кода или имён полей JSON.

Обмен значениями и множественное присваивание

Начиная с C# 7, кортежи позволяют присвоить несколько переменных в одном операторе, что даёт обмен значений в одну строку:

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}");
    }
}

Вывод:

20 10
Lisbon: 545,000

Вторая форма это деконструкция: она объявляет city как string и population как int из кортежа. Подробнее в разделе кортежи.