Урок 8.7 — Аннотации типов и null-безопасность

C# — строго типизированный язык. Это значит, что тип каждой переменной, параметра, выражения известен на этапе компиляции. Если ты попытаешься использовать значение не по типу — компилятор выдаст ошибку.

int number = 42;
string text = "Привет";

// number = "текст";  // ❌ Ошибка компиляции: нельзя string в int
// text = 42;         // ❌ Ошибка компиляции: нельзя int в string

// Неявное приведение типов:
double d = 10;        // int → double (безопасно, не теряется)
int i = (int)3.14;    // double → int (нужно явное приведение, теряется 0.14)

// Тип выражения определяется на этапе компиляции:
var sum = 10 + 20;    // sum имеет тип int
var name = "Анна";    // name имеет тип string

var — это не «тип-невидимка», а синтаксический сахар. Компилятор самостоятельно определяет тип переменной на основе выражения справа. Тип фиксируется на этапе компиляции и не может измениться.

var number = 42;           // int
var price = 19.99m;        // decimal
var name = "Анна";         // string
var isActive = true;       // bool
var list = new List<int>();  // List<int>
var person = new Person();    // Person

// ❌ Нельзя использовать var без инициализации:
// var x;           // ошибка!
// var y = null;    // ошибка — тип не определить!

// ❌ Нельзя изменить тип:
var value = 10;
// value = "текст";  // ошибка — value уже int

До C# 8.0 ссылочные типы (string, object, классы) могли быть null без каких-либо предупреждений. Начиная с C# 8.0, ты можешь явно указать, может ли переменная быть null — с помощью символа ?.

// Enable nullable в .csproj или в файле:
// #nullable enable

string name = "Анна";     // НЕ может быть null — гарантия
string? maybeNull = null; // МОЖЕТ быть null — предупреждение, если не проверить

// name = null;     // ⚠️ Предупреждение! string не должен быть null
// maybeNull = null; // ✅ Нормально, это ожидаемо

// При использовании nullable-переменной нужно проверить:
if (maybeNull != null)
{
    Console.WriteLine(maybeNull.Length);  // ✅ Безопасно
}

// Или через null-conditional:
Console.WriteLine(maybeNull?.Length);     // ✅ Безопасно, вернёт null

C# предлагает два мощных оператора для безопасной работы с null. Они позволяют писать лаконичный и безопасный код без громоздких if-проверок.

Person? person = GetPerson();

// Без ?. — нужно писать проверку:
if (person != null)
{
    Console.WriteLine(person.Name);
}

// С ?. — лаконично и безопасно:
Console.WriteLine(person?.Name);  // если person null, то ничего не произойдёт

// Цепочка ?.:
string? cityName = person?.Address?.City?.Name;
// Если любой из них null → cityName = null

// Для вызова методов:
person?.PrintInfo();  // если person не null — вызовется

string? input = GetUserInput();
string result = input ?? "Значение по умолчанию";
// Если input null → используем "Значение по умолчанию"

// Комбинация ?. и ??:
int? length = person?.Name?.Length ?? 0;
// Если person или Name null → length = 0

// ??= (C# 8+): присвоить, если null
string? name = null;
name ??= "Гость";  // name теперь "Гость"
name ??= "Админ";  // name уже не null, ничего не изменится

В C# есть несколько способов проверить значение на null. Самый современный — использовать паттерн-матчинг с is null и is not null.

string? text = GetText();

// Стиль 1: классический (C# 1.0+)
if (text != null) { /* ... */ }

// Стиль 2: is null (C# 7.0+)
if (text is null) { /* ... */ }

// Стиль 3: is not null (C# 9.0+)
if (text is not null) { /* ... */ }

// Стиль 4: паттерн-матчинг (C# 9.0+)
if (text is string) { /* text не null и доступен */ }

// Стиль 5: null-coalescing
string result = text ?? "default";

// Стиль 6: null-conditional
int? length = text?.Length;

int nonNullable = 42;     // int не может быть null
int? nullable = null;     // int? может быть null

// int? — это на самом деле Nullable<int>
// У nullable типов есть свойства:
if (nullable.HasValue)
{
    Console.WriteLine(nullable.Value);  // безопасное получение значения
}

// Преобразование:
int regular = nullable ?? 0;           // null → 0
int another = nullable.GetValueOrDefault(); // то же самое

В C# есть атрибуты, которые помогают компилятору и анализаторам понимать семантику null. Они находятся в пространстве имён System.Diagnostics.CodeAnalysis.

using System.Diagnostics.CodeAnalysis;

public class UserService
{
    // [NotNull] — метод не возвращает null
    [return: NotNull]
    public string GetUserName(int id)
    {
        return "Анна";
    }

    // [MaybeNull] — метод может вернуть null
    [return: MaybeNull]
    public string? FindUser(int id)
    {
        // может быть null
        return null;
    }

    // [NotNullWhen(true)] — если метод вернул true, параметр не null
    public bool TryGetUser(int id, [NotNullWhen(true)] out User? user)
    {
        if (id > 0)
        {
            user = new User();
            return true;
        }
        user = null;
        return false;
    }
}