Nullable типы и операторы объединения null в C#

string name = null; // Нормально, ссылочный тип
int number = null;  // Ошибка компиляции! Значимый тип не может быть null

string text = null;
int length = text.Length; // Бум! NullReferenceException

// Антипаттерн: избыточные проверки на null
if (customer != null)
{
    if (customer.Orders != null)
    {
        if (customer.Orders.LastOrder != null)
        {
            // Наконец-то можем что-то сделать...
        }
    }
}

// Старый подход с "магическими" значениями
DateTime hireDate = new DateTime(2020, 5, 10);
DateTime terminationDate = DateTime.MinValue; // "Магическое" значение для отсутствия даты
 
// Проверка
if (terminationDate == DateTime.MinValue)
{
    Console.WriteLine("Сотрудник все еще работает");
}

// Полный синтаксис
Nullable<int> nullableInt = null;
 
// Сокращенный синтаксис (предпочтительный)
int? nullableInt = null;
 
// Примеры с другими типами
bool? nullableBool = null;
DateTime? nullableDate = null;

// Упрощенная версия внутренней реализации
public struct Nullable<T> where T : struct
{
    private bool hasValue;
    internal T value;
 
    public Nullable(T value)
    {
        this.value = value;
        this.hasValue = true;
    }
 
    public bool HasValue { get { return hasValue; } }
    
    public T Value
    {
        get
        {
            if (!hasValue)
            {
                throw new InvalidOperationException("Nullable object must have a value.");
            }
            return value;
        }
    }
 
    // Дополнительные методы...
}

int? number = 42;
 
// Проверка наличия значения
bool hasValue = number.HasValue; // true
 
// Получение значения (опасно, если null)
int value = number.Value; // 42
 
// Безопасное получение значения с дефолтом
int safeValue = number.GetValueOrDefault(); // 42
int safeValueWithCustomDefault = number.GetValueOrDefault(100); // 42
 
// Если number = null
// safeValue будет 0 (default для int)
// safeValueWithCustomDefault будет 100

// Неявное преобразование из T в T?
int regular = 42;
int? nullable = regular; // Работает без явного приведения
 
// Явное преобразование из T? в T
int? nullable = 42;
int regular = (int)nullable; // Требуется явное приведение
// Внимание! Если nullable == null, произойдет InvalidOperationException

int? a = 5;
int? b = 10;
int? c = null;
 
int? sum1 = a + b;    // 15
int? sum2 = a + c;    // null (5 + null = null)
bool? comparison = a < b;  // true
bool? nullComparison = a < c;  // null (5 < null = null)

int? nullableNumber = GetSomeValue(); // Может вернуть null
 
// Компилятор предупредит нас, что нужно проверить на null
// перед использованием Value
if (nullableNumber.HasValue)
{
    int actualNumber = nullableNumber.Value;
    // Дальнейшая работа с actualNumber
}
else
{
    // Обработка отсутствия значения
}

// C# 8.0 с включенными nullable reference types
string nonNullableString = null; // Предупреждение компилятора
string? nullableString = null; // Всё в порядке

public struct Option<T>
{
    private readonly T _value;
    private readonly bool _hasValue;
 
    private Option(T value)
    {
        _value = value;
        _hasValue = true;
    }
 
    public static Option<T> Some(T value) => new Option<T>(value);
    public static Option<T> None => new Option<T>();
 
    public TResult Match<TResult>(Func<T, TResult> some, Func<TResult> none) =>
        _hasValue ? some(_value) : none();
}
 
// Использование:
Option<int> result = GetOptionalValue();
int display = result.Match(
    some: value => value,
    none: () => -1
);

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; } // В EF Core 3.x это поле не может быть null
    public string? OptionalField { get; set; } // Явно указываем, что поле может быть null
}

// ASP.NET Core контроллер
[HttpGet]
public ActionResult<Customer?> GetCustomer(int id)
{
    var customer = _repository.FindById(id);
    if (customer == null)
        return NotFound();
    return customer;
}

// Не скомпилируется - T может быть как значимым, так и ссылочным типом
public T? ProcessData<T>(T input) { ... }
 
// Правильный подход для nullable value types
public T? ProcessValueType<T>(T input) where T : struct { ... }
 
// Для ссылочных типов с C# 8.0+
public T? ProcessReferenceType<T>(T input) where T : class { ... }

public static class MaybeExtensions
{
    // Для значимых типов
    public static T? ToNullable<T>(this T value) where T : struct => value;
    
    // Для ссылочных типов
    public static T? AsNullable<T>(this T value) where T : class => value;
    
    // Безопасное получение значения
    public static TResult Map<T, TResult>(this T? nullable, Func<T, TResult> mapper, TResult defaultValue = default)
        where T : struct
    {
        return nullable.HasValue ? mapper(nullable.Value) : defaultValue;
    }
}

public async Task<User?> FindUserAsync(string username)
{
    try
    {
        var result = await _userRepository.FindByNameAsync(username);
        return result; // Может быть null, если пользователь не найден
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Ошибка при поиске пользователя");
        return null; // Возвращаем null в случае ошибки
    }
}
 
// Использование
var user = await FindUserAsync("johndoe");
if (user != null)
{
    await SendNotificationAsync(user);
}

int? number = GetPossibleNumber();
 
// Pattern matching с nullable-типом
switch (number)
{
    case null:
        Console.WriteLine("Значение отсутствует");
        break;
    case int n when n > 100:
        Console.WriteLine($"Большое число: {n}");
        break;
    case int n:
        Console.WriteLine($"Обычное число: {n}");
        break;
}

string result = number switch
{
    null => "Значение отсутствует",
    > 100 => $"Большое число: {number}",
    _ => $"Обычное число: {number}"
};

#nullable enable
string nonNullableString = null; // Предупреждение: Assignment of null to non-nullable reference type
string? nullableString = null;   // Всё в порядке
 
// Предупреждение при возможном null
void ProcessText(string? text)
{
    int length = text.Length; // Предупреждение: Possible null reference exception
    
    // Правильный подход:
    if (text != null)
    {
        int length = text.Length;
    }
    
    // Или более кратко:
    int safeLength = text?.Length ?? 0;
}

int? nullableInt = 42;
object boxed = nullableInt; // Упаковывается сама структура Nullable<int>, а не значение
 
// Для получения упакованного значения:
object boxedValue = nullableInt.HasValue ? (object)nullableInt.Value : null;

// Избегаем повторных проверок на HasValue
int? number = GetNumber();
if (number.HasValue)
{
    int value = number.Value; // Используем Value только один раз
    // Работаем с value
}
 
// Или еще лучше:
if (number is int actualNumber) // Pattern matching извлекает значение
{
    // Работаем с actualNumber
}

// Ошибка 1: Необработанные null значения
int? age = GetAge();
int years = age.Value; // Может вызвать InvalidOperationException
 
// Решение: Всегда проверять HasValue или использовать GetValueOrDefault
int years = age.GetValueOrDefault();
 
// Ошибка 2: Потеря null в LINQ запросах
var query = from person in people
            select person.Age + 5; // Если Age = null, результат будет null
 
// Решение: Обрабатывать null явно
var query = from person in people
            select person.Age.HasValue ? person.Age.Value + 5 : (int?)null;
 
// Ошибка 3: Непонимание равенства null
int? a = null;
int? b = null;
bool areEqual = (a == b); // true, два null считаются равными
bool areTheSame = object.ReferenceEquals(a, b); // false, это разные экземпляры

public readonly struct Optional<T>
{
    private readonly T _value;
    public bool HasValue { get; }
    
    public Optional(T value)
    {
        _value = value;
        HasValue = value != null;
    }
    
    public T Value => HasValue ? _value : throw new InvalidOperationException("No value");
    
    public T GetValueOrDefault(T defaultValue = default) => HasValue ? _value : defaultValue;
    
    public Optional<TResult> Select<TResult>(Func<T, TResult> selector) =>
        HasValue ? new Optional<TResult>(selector(_value)) : new Optional<TResult>();
}

// Синтаксис: левый_операнд ?? правый_операнд
// Возвращает левый операнд, если он не null, иначе - правый операнд
 
string name = GetUserName() ?? "Неизвестный пользователь";

string username = GetUserName();
if (username == null)
{
    username = "Неизвестный пользователь";
}

int? possibleAge = GetAge(); // Может вернуть null
int actualAge = possibleAge ?? 18; // Если null, используем значение по умолчанию 18

string result = firstChoice ?? secondChoice ?? thirdChoice ?? "Запасной вариант";

// Вместо:
string city = null;
if (customer != null && customer.Address != null)
{
    city = customer.Address.City;
}
 
// Можно писать:
string city = customer?.Address?.City;

// Безопасное обращение к элементу массива
char? firstChar = someArray?[0];
 
// Безопасный вызов метода
int? count = customers?.Count();

// Безопасный вызов события
// Вместо: if (PropertyChanged != null) PropertyChanged(this, args);
PropertyChanged?.Invoke(this, args);

// Вместо:
if (result == null)
{
    result = GetDefaultValue();
}
 
// Используем:
result ??= GetDefaultValue();

private List<Order> _orders;
public List<Order> Orders
{
    get
    {
        // Ленивая инициализация: создаем список только при первом обращении
        _orders ??= new List<Order>();
        return _orders;
    }
}

public Customer GetCustomer(int id)
{
    // Если в кэше нет значения, получаем его из БД и сохраняем
    _customerCache[id] ??= _database.LoadCustomer(id);
    return _customerCache[id];
}

// Безопасное получение города из цепочки объектов с запасным значением
string city = customer?.Address?.City ?? "Неизвестный город";
 
// Комбинирование с вызовом метода
int nameLength = user?.Name?.Length ?? 0;

// Без использования null-операторов
string GetUserDisplayName(int userId)
{
    var user = _repository.GetUser(userId);
    if (user != null)
    {
        if (user.Profile != null)
        {
            if (!string.IsNullOrEmpty(user.Profile.DisplayName))
            {
                return user.Profile.DisplayName;
            }
        }
    }
    return $"User_{userId}";
}
 
// С использованием комбинации операторов
string GetUserDisplayName(int userId)
{
    return _repository.GetUser(userId)?.Profile?.DisplayName ?? $"User_{userId}";
}

string city = customer?.DeliveryAddress?.City ?? customer?.BillingAddress?.City ?? "Неизвестный город";

public static class StringExtensions
{
    public static string OrEmpty(this string value) => value ?? string.Empty;
    
    public static string Truncate(this string value, int maxLength) =>
        value?.Length > maxLength ? value.Substring(0, maxLength) : value;
}
 
// Использование
string description = product?.Description.OrEmpty().Truncate(100);

// Оператор ?. может генерировать дополнительные проверки на null
// В цикле с большим числом итераций это может быть заметно
for (int i = 0; i < 1000000; i++)
{
    var temp = items[i]?.Value;  // Каждый раз проверка на null
}
 
// В критичных местах иногда эффективнее явная проверка
if (items[i] != null)
{
    for (int i = 0; i < 1000000; i++)
    {
        var temp = items[i].Value;  // Проверка выполнена только один раз
    }
}

// Правая часть вычисляется в любом случае
string name = currentUser.Name ?? GetDefaultNameFromDatabase();
 
// Более эффективный подход
string name = currentUser.Name;
if (name == null)
{
    name = GetDefaultNameFromDatabase();
}

// Лямбда выражение выполнится только если currentUser.Name == null
string name = currentUser.Name ?? (() => GetDefaultNameFromDatabase())();

// Фильтрация null-значений в коллекции
var validItems = items.Where(i => i?.Status == "Active");
 
// Внимание! В этом случае будут отфильтрованы и null-элементы,
// и элементы с Status != "Active"

var nonNullItems = items.Where(i => i != null);
var activeItems = nonNullItems.Where(i => i.Status == "Active");
 
// Или в одну строку с явной обработкой null
var activeItems = items.Where(i => i != null && i.Status == "Active");

// Плоское отображение без null-значений
var allOrders = customers
    .SelectMany(c => c?.Orders ?? Enumerable.Empty<Order>());

// Вместо многократных проверок на null и типы
public string FormatValue(object value)
{
    if (value == null)
        return "N/A";
    
    if (value is int intValue)
        return $"{intValue:D}";
    
    if (value is DateTime dateValue)
        return $"{dateValue:yyyy-MM-dd}";
    
    return value.ToString();
}
 
// Можно использовать switch-выражение с сопоставлением образцов
public string FormatValue(object value) => value switch
{
    null => "N/A",
    int i => $"{i:D}",
    DateTime d => $"{d:yyyy-MM-dd}",
    _ => value.ToString()
};

// Типичный сценарий, где возможно исключение
public decimal CalculateOrderTotal(Order order)
{
    // Если order == null или order.Items == null, получим NullReferenceException
    return order.Items.Sum(item => item.Price * item.Quantity);
}
 
// Безопасный вариант с использованием nullable-операторов
public decimal CalculateOrderTotal(Order order)
{
    return order?.Items?.Sum(item => item?.Price * item?.Quantity) ?? 0m;
}

// Извлечение настройки из конфигурации с несколькими уровнями вложенности
bool isFeatureEnabled = configuration
    ?.GetSection("Features")
    ?.GetSection("Experimental")
    ?.GetValue<bool>("EnableNewUI") ?? false;

// Традиционный подход с вложенными проверками
public string GetCustomerCity(int customerId)
{
    var customer = _repository.GetCustomer(customerId);
    if (customer != null)
    {
        var address = customer.PrimaryAddress;
        if (address != null)
        {
            var city = address.City;
            if (!string.IsNullOrEmpty(city))
            {
                return city;
            }
        }
    }
    return "Unknown";
}
 
// Тот же код с использованием операторов null
public string GetCustomerCity(int customerId)
{
    return _repository.GetCustomer(customerId)
        ?.PrimaryAddress
        ?.City
        ?? "Unknown";
}

// Традиционный подход
protected virtual void OnPropertyChanged(string propertyName)
{
    var handler = PropertyChanged;
    if (handler != null)
    {
        handler(this, new PropertyChangedEventArgs(propertyName));
    }
}
 
// С использованием оператора условного null
protected virtual void OnPropertyChanged(string propertyName)
{
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}

// Метод в контроллере ASP.NET Core для поиска пользователей
[HttpGet("search")]
public async Task<IActionResult> SearchUsers(
    string query,
    int? limit = null,
    int? offset = null,
    string sortBy = null)
{
    var results = await _userService.SearchAsync(
        query,
        limit ?? DefaultPageSize,
        offset ?? 0,
        sortBy ?? "LastName");
    
    return Ok(results);
}

public interface INotificationService
{
    Task SendNotificationAsync(
        string userId,
        string message,
        NotificationType type,
        DateTime? scheduledTime = null,
        int? priority = null);
}
 
public class NotificationService : INotificationService
{
    public async Task SendNotificationAsync(
        string userId,
        string message,
        NotificationType type,
        DateTime? scheduledTime = null,
        int? priority = null)
    {
        if (scheduledTime.HasValue && scheduledTime > DateTime.UtcNow)
        {
            // Отложенная отправка
            await ScheduleNotification(userId, message, type, scheduledTime.Value, priority ?? DefaultPriority);
        }
        else
        {
            // Немедленная отправка
            await SendImmediately(userId, message, type, priority ?? DefaultPriority);
        }
    }
}

public class CachedRepository<T>
{
    private readonly SemaphoreSlim _lock = new SemaphoreSlim(1, 1);
    private readonly Dictionary<string, Tuple<T, DateTime>> _cache = new Dictionary<string, Tuple<T, DateTime>>();
    private readonly TimeSpan _cacheLifetime;
    
    public async Task<T?> GetByKeyAsync(string key)
    {
        // Попытка получить из кэша без блокировки
        if (_cache.TryGetValue(key, out var cached))
        {
            if (DateTime.UtcNow - cached.Item2 < _cacheLifetime)
            {
                return cached.Item1;
            }
        }
        
        // Нужно обновить кэш, получаем блокировку
        await _lock.WaitAsync();
        try
        {
            // Повторная проверка после получения блокировки
            if (_cache.TryGetValue(key, out cached) && 
                DateTime.UtcNow - cached.Item2 < _cacheLifetime)
            {
                return cached.Item1;
            }
            
            // Получаем свежие данные
            T? freshData = await FetchFromSourceAsync(key);
            
            // Обновляем кэш, если данные получены
            if (freshData != null)
            {
                _cache[key] = Tuple.Create(freshData, DateTime.UtcNow);
            }
            else
            {
                _cache.Remove(key);
            }
            
            return freshData;
        }
        finally
        {
            _lock.Release();
        }
    }
    
    private async Task<T?> FetchFromSourceAsync(string key)
    {
        // Реализация получения данных из источника
        // Может вернуть null, если данные не найдены
    }
}

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; } = null!; // Обязательное поле
    public string? Email { get; set; }        // Необязательное поле
    public DateTime RegistrationDate { get; set; }
    public DateTime? LastLoginDate { get; set; } // Может быть null
}

// Найти клиентов, которые ещё не входили в систему
var newCustomers = await _context.Customers
    .Where(c => c.LastLoginDate == null)
    .ToListAsync();
 
// Найти клиентов, которые входили в систему в этом месяце
var activeCustomers = await _context.Customers
    .Where(c => c.LastLoginDate != null && 
                c.LastLoginDate.Value.Month == DateTime.Now.Month)
    .ToListAsync();

public CustomerDto MapToDto(Customer customer)
{
    return new CustomerDto
    {
        Id = customer.Id,
        Name = customer.Name,
        Email = customer.Email ?? "Не указан",
        DaysSinceLastLogin = customer.LastLoginDate?.Subtract(DateTime.Today).Days
    };
}

public interface IRepository<T>
{
    Task<T?> GetByIdAsync(int id);
    Task<List<T>> GetAllAsync();
    Task<bool> AddAsync(T entity);
    Task<bool> UpdateAsync(T entity);
    Task<bool> DeleteAsync(int id);
}
 
public class Repository<T> : IRepository<T> where T : class, IEntity
{
    private readonly DbContext _context;
    private readonly DbSet<T> _dbSet;
 
    public Repository(DbContext context)
    {
        _context = context;
        _dbSet = context.Set<T>();
    }
 
    public async Task<T?> GetByIdAsync(int id)
    {
        return await _dbSet.FindAsync(id);
        // Метод возвращает null, если сущность не найдена
    }
 
    // Другие методы...
}

   #nullable enable
   // Новый код с поддержкой nullable reference types

   #nullable enable
   // Код с поддержкой nullable reference types
   #nullable disable
   // Старый код без поддержки nullable reference types

// До включения nullable reference types:
public string GetUserName(User user)
{
    // Опасно! Без проверки на null
    return user.Profile.Name;
}
 
// После включения nullable reference types:
public string GetUserName(User user)
{
    // Компилятор предупредит, что user.Profile может быть null
    return user.Profile?.Name ?? "Безымянный";
}

// Версия 1.0 - без nullable аннотаций
public class ApiClient
{
    public User GetUser(string id) { /* ... */ }
}
 
// Версия 2.0 - с nullable аннотациями
public class ApiClient
{
    public User? GetUser(string id) { /* ... */ }
    // Добавляем nullable, потому что метод может вернуть null
    // Это изменение может повлиять на клиентский код!
}

// Используйте nullable-типы для:
// 1. Представления опциональных данных
DateTime? completionDate; // Дата завершения может отсутствовать
 
// 2. API, которые могут не вернуть результат
Customer? FindCustomerById(int id); // Клиент может не существовать
 
// 3. Параметров методов с необязательными значениями
void GenerateReport(DateTime startDate, DateTime? endDate = null);

// Избегайте использования nullable-типов когда:
// 1. Значение всегда должно быть предоставлено
void ProcessOrder(Order? order); // Плохо: заменить на void ProcessOrder(Order order)
 
// 2. Можно использовать коллекцию вместо null
// Плохо:
List<Product>? GetProducts();
// Лучше: 
List<Product> GetProducts(); // Возвращает пустой список, если продуктов нет

// Трудно определить, на каком этапе возник null
var result = a?.b?.c?.d?.e?.f?.Method();
 
// Лучше разбить на отдельные проверяемые шаги
var bValue = a?.b;
if (bValue != null)
{
    var cValue = bValue.c;
    // ...и так далее
}

public string FullName { get; set; } = null!; // Маркер "доверяй мне" - опасно!

const int NOT_FOUND = -1;
int indexOf = array.IndexOf(element); // Возвращает -1, если не найдено

// Плохо:
List<Customer>? GetCustomers() => customers.Any() ? customers : null;
 
// Хорошо:
List<Customer> GetCustomers() => customers.Any() ? customers : new List<Customer>();

// Вместо null используем NullLogger
ILogger logger = configuration.EnableLogging ? new FileLogger() : new NullLogger();
logger.Log("Сообщение"); // Всегда работает, даже с NullLogger

// Вместо:
User? TryGetUser(int id);
 
// Лучше использовать:
bool TryGetUser(int id, out User user);

[TestMethod]
public void GetUserInfo_WithNullUser_ReturnsDefaultInfo()
{
    // Arrange
    User? user = null;
    var service = new UserService();
    
    // Act
    var result = service.GetUserInfo(user);
    
    // Assert
    Assert.AreEqual("Гость", result.Name);
    Assert.AreEqual(0, result.Age);
}
 
[TestMethod]
public void GetUserInfo_WithValidUser_ReturnsCorrectInfo()
{
    // Arrange
    User user = new User { Name = "Алексей", Age = 30 };
    var service = new UserService();
    
    // Act
    var result = service.GetUserInfo(user);
    
    // Assert
    Assert.AreEqual("Алексей", result.Name);
    Assert.AreEqual(30, result.Age);
}

[TestMethod]
[DataRow(null, null, "Неизвестно")] // Оба параметра null
[DataRow("Иван", null, "Иван")] // Второй параметр null
[DataRow(null, "Петров", "Петров")] // Первый параметр null
[DataRow("Иван", "Петров", "Иван Петров")] // Нет null параметров
public void FormatName_WithVariousNullability_ReturnsExpectedResult(string firstName, string lastName, string expected)
{
    // Act
    string result = StringFormatter.FormatName(firstName, lastName);
    
    // Assert
    Assert.AreEqual(expected, result);
}

[TestMethod]
public void ProcessCustomerData_WhenAddressIsNull_DoesNotThrow()
{
    // Arrange
    var customer = new Customer { Name = "Анна" }; // Address = null
    var processor = new DataProcessor();
    
    // Act & Assert
    // Не должно возникнуть исключения
    processor.ProcessCustomerData(customer);
}

// До C# 8.0
public interface IProductFactory
{
    Product CreateProduct(string type); // Может вернуть null
}
 
// С C# 8.0
public interface IProductFactory
{
    Product? CreateProduct(string type); // Явно указываем возможность null
}
 
// Реализация
public class ProductFactory : IProductFactory
{
    public Product? CreateProduct(string type)
    {
        return type switch
        {
            "Book" => new Book(),
            "Electronic" => new Electronic(),
            _ => null // Неизвестный тип продукта
        };
    }
}
 
// Использование
var factory = new ProductFactory();
var product = factory.CreateProduct("Book");
if (product != null)
{
    product.Process();
}

public interface IDiscountStrategy
{
    decimal CalculateDiscount(Order order);
}
 
public class DiscountService
{
    private IDiscountStrategy? _strategy;
    
    public void SetStrategy(IDiscountStrategy? strategy)
    {
        _strategy = strategy;
    }
    
    public decimal ApplyDiscount(Order order)
    {
        // Если стратегия не установлена, скидка не применяется
        decimal discount = _strategy?.CalculateDiscount(order) ?? 0;
        return order.Total - discount;
    }
}

public class EmailBuilder
{
    private Email _email = new Email();
    
    public EmailBuilder? From(string address)
    {
        if (!IsValidEmail(address))
            return null; // Возвращаем null при ошибке
        
        _email.From = address;
        return this;
    }
    
    public EmailBuilder? To(string address)
    {
        if (!IsValidEmail(address))
            return null;
        
        _email.To = address;
        return this;
    }
    
    public Email? Build() => _email.From != null && _email.To != null ? _email : null;
}
 
// Использование с обработкой возможных null-значений в цепочке
Email? email = new EmailBuilder()
    ?.From("sender@example.com")
    ?.To("recipient@example.com")
    ?.WithSubject("Тестовое письмо")
    ?.Build();
 
if (email != null)
{
    _emailService.Send(email);
}

// Базовый интерфейс
public interface ILogger
{
    void Log(string message);
}
 
// Реальная реализация
public class FileLogger : ILogger
{
    public void Log(string message)
    {
        File.AppendAllText("app.log", message + Environment.NewLine);
    }
}
 
// Реализация-пустышка
public class NullLogger : ILogger
{
    public void Log(string message)
    {
        // Ничего не делаем
    }
}
 
// Вместо:
ILogger? logger = settings.EnableLogging ? new FileLogger() : null;
logger?.Log("Сообщение"); // Проверка на null при каждом вызове
 
// Используем:
ILogger logger = settings.EnableLogging ? new FileLogger() : new NullLogger();
logger.Log("Сообщение"); // Всегда безопасно, проверки не требуются

public class Person
{
    public string Name { get; set; } = null!;
    public int? Age { get; set; }
    public DateTime? BirthDate { get; set; }
}
 
// Сериализация объекта с nullable-свойствами
var person = new Person { Name = "Иван", Age = null, BirthDate = new DateTime(1990, 1, 1) };
string json = JsonSerializer.Serialize(person);
// Результат: {"Name":"Иван","BirthDate":"1990-01-01T00:00:00"}
// Обратите внимание: null-свойство Age отсутствует!

// Настройка для включения null-значений
var options = new JsonSerializerOptions
{
    IgnoreNullValues = false // System.Text.Json < 5.0
    // DefaultIgnoreCondition = JsonIgnoreCondition.Never // System.Text.Json >= 5.0
};
 
string jsonWithNulls = JsonSerializer.Serialize(person, options);
// Результат: {"Name":"Иван","Age":null,"BirthDate":"1990-01-01T00:00:00"}

string jsonWithoutAge = "{\"Name\":\"Иван\",\"BirthDate\":\"1990-01-01\"}";
Person? deserializedPerson = JsonSerializer.Deserialize<Person>(jsonWithoutAge);
// deserializedPerson.Age будет null (значение по умолчанию для int?)

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; } = null!; // Не может быть null
    public string? Title { get; set; }        // Может быть null
    public DateTime HireDate { get; set; }    // Не может быть null
    public DateTime? TerminationDate { get; set; } // Может быть null
}
 
// В Fluent API можно явно указать поведение
modelBuilder.Entity<Employee>()
    .Property(e => e.Name)
    .IsRequired(); // NOT NULL
 
modelBuilder.Entity<Employee>()
    .Property(e => e.Title)
    .IsRequired(false); // NULL allowed

// Запрос, который может вернуть NULL для некоторых полей
string sql = "SELECT Id, Name, Title, HireDate, TerminationDate FROM Employees WHERE Id = @Id";
 
// Правильная модель с nullable-полями
var employee = await connection.QuerySingleOrDefaultAsync<Employee>(sql, new { Id = 1 });
 
// Если Title = NULL в БД, но в C# модели это string (не string?),
// большинство ORM установят его в пустую строку, а не в null

// C# код
var person = new Person
{
    Name = "Алексей",
    Age = null, // Будет передано как отсутствующее поле
    OptionalField = "Значение" // Будет передано со значением
};
 
// При получении
if (person.Age == null)
{
    // Поле не было установлено
}

   public static T? DeserializeWithValidation<T>(string json) where T : class
   {
       try
       {
           var result = JsonSerializer.Deserialize<T>(json);
           // Дополнительные проверки для убеждения, что все необходимые данные присутствуют
           return result;
       }
       catch (JsonException ex)
       {
           _logger.LogError(ex, "Ошибка десериализации");
           return null;
       }
   }

   // DTO для сериализации
   public class PersonDto
   {
       public string? Name { get; set; }
       public int? Age { get; set; }
   }
   
   // Доменная модель
   public class Person
   {
       public string Name { get; } = string.Empty;
       public int? Age { get; }
       
       public Person(string name, int? age)
       {
           Name = string.IsNullOrEmpty(name) ? "Неизвестно" : name;
           Age = age;
       }
       
       // Маппинг из DTO
       public static Person FromDto(PersonDto dto)
       {
           return new Person(dto.Name ?? "Неизвестно", dto.Age);
       }
   }

// До введения nullable reference types
/// <summary>
/// Получает пользователя по идентификатору.
/// </summary>
/// <param name="id">Идентификатор пользователя.</param>
/// <returns>Пользователь или null, если пользователь не найден.</returns>
public User GetUser(int id) { ... }
 
// С использованием nullable reference types
/// <summary>
/// Получает пользователя по идентификатору.
/// </summary>
/// <param name="id">Идентификатор пользователя.</param>
/// <returns>Пользователь или null, если пользователь не найден.</returns>
public User? GetUser(int id) { ... }

/// <summary>
/// Обрабатывает данные пользователя.
/// </summary>
/// <param name="user">Информация о пользователе. Не может быть null.</param>
/// <exception cref="ArgumentNullException">Выбрасывается, если user равен null.</exception>
public void ProcessUserData(User user)
{
    if (user == null)
        throw new ArgumentNullException(nameof(user));
    
    // Обработка данных
}

// Контракт данных для микросервиса
public class UserProfileContract
{
    // Обязательные поля
    public string Id { get; set; } = null!;
    public string Username { get; set; } = null!;
    
    // Необязательные поля
    public string? DisplayName { get; set; }
    public DateTime? LastLoginDate { get; set; }
}
 
// Валидация на границе сервиса
public async Task<IActionResult> UpdateProfile([FromBody] UserProfileContract request)
{
    // Валидация обязательных полей
    if (string.IsNullOrEmpty(request.Id) || string.IsNullOrEmpty(request.Username))
        return BadRequest("Обязательные поля отсутствуют");
    
    // Преобразование в доменную модель
    var profile = new UserProfile(
        request.Id,
        request.Username,
        request.DisplayName ?? string.Empty,
        request.LastLoginDate
    );
    
    await _userService.UpdateProfileAsync(profile);
    return Ok();
}

// Настройка System.Text.Json для строгой обработки обязательных свойств
services.AddControllers()
    .AddJsonOptions(options =>
    {
        options.JsonSerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
        options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
    });
 
// Для Newtonsoft.Json можно использовать аннотации
public class StrictContract
{
    [JsonProperty(Required = Required.Always)]
    public string MustHaveValue { get; set; } = null!;
    
    [JsonProperty(Required = Required.Default)]
    public string? OptionalValue { get; set; }
}

// Вместо повторной проверки nullable-значения в цикле
int? nullableValue = GetSomeValue();
if (nullableValue.HasValue)
{
    int value = nullableValue.Value;
    for (int i = 0; i < 1000000; i++)
    {
        // Работаем с извлеченным значением без повторных проверок
        DoSomething(value);
    }
}
 
// Для коллекций с возможными null-элементами
// предварительно фильтруем null-значения перед обработкой
var nonNullItems = items.Where(i => i != null).ToList();
foreach (var item in nonNullItems)
{
    // Работаем без проверок на null
    Process(item);
}

   #nullable enable
   // Код с предупреждениями
   #pragma warning disable CS8600, CS8602, CS8603

// Старый небезопасный API
public class LegacyUserRepository
{
    public User GetUser(int id) { /* может вернуть null */ }
}
 
// Типобезопасная обёртка
public class SafeUserRepository
{
    private readonly LegacyUserRepository _repository;
    
    public User? GetUser(int id)
    {
        return _repository.GetUser(id);
    }
    
    public bool TryGetUser(int id, out User user)
    {
        var result = _repository.GetUser(id);
        user = result!; // Используем оператор ! если уверены
        return result != null;
    }
}

// Аннотированный контракт публичного API
public interface IUserService
{
    User? FindById(int id);
    IEnumerable<User> GetAllActive(); // Не может быть null, только пустая коллекция
    bool TryGetDetails(int userId, out UserDetails details);
}
 
// Реализация может постепенно адаптироваться под контракт
public class UserService : IUserService
{
    // Внутренняя реализация может временно использовать #pragma
    #pragma warning disable CS8603
    public User? FindById(int id)
    {
        // Временно неоптимальный код, который будет улучшен
        return _repository.GetUser(id);
    }
    #pragma warning restore CS8603
    
    // ...
}

   /// <summary>
   /// Находит пользователя по имени.
   /// </summary>
   /// <returns>
   /// Пользователь или null, если пользователь не найден.
   /// </returns>
   public User? FindByName(string name);

   // Всегда возвращать пустую коллекцию вместо null
   public IEnumerable<Order> GetOrders(int customerId)
   {
       var orders = _repository.FindOrdersByCustomer(customerId);
       return orders ?? Enumerable.Empty<Order>();
   }

   public void ProcessOrder(Order order)
   {
       if (order == null)
           throw new ArgumentNullException(nameof(order));
       
       // Основная логика
   }

   public class NullLogger : ILogger
   {
       public void Log(string message) { /* Ничего не делает */ }
   }
   
   // Использование
   public class Service
   {
       private readonly ILogger _logger;
       
       public Service(ILogger? logger = null)
       {
           _logger = logger ?? new NullLogger();
       }
   }