Обработка нулевых ссылок в C# когда компилятор не может гарантировать инициализацию

Рекомендуемый подход к обработке потенциально нулевых ссылок в C#

Рекомендуемый подход к обработке потенциально нулевых ссылок в C# в ситуациях, когда вы знаете, что они будут инициализированы до использования, но компилятор не может гарантировать это, зависит от вашего конкретного сценария. Основными решениями являются оператор “прощения null” !, правильное использование атрибутов нулевого состояния, таких как MemberNotNullWhen, и проектирование структуры кода для предоставления компилятору гарантий инициализации.

Содержание

• Оператор “прощения null” (!)
• Атрибут MemberNotNullWhen
• Шаблоны проектирования для гарантированной инициализации
• Конфигурация компилятора и параметры проекта
• Лучшие практики и рекомендации
• Альтернативные подходы

Оператор “прощения null” (!)

Оператор “прощения null” (null-forgiving) является наиболее прямым решением для подавления предупреждений компилятора, когда у вас есть внешние знания о том, что ссылка не будет равна null. Согласно документации Microsoft, унарный префиксный оператор ! подавляет все предупреждения о nullable для предшествующего выражения.

static string[]? foodItems = null;

// Позже в вашем коде:
if (foodItems!.Contains("cookie"))
{
    // Обработать результат
}

Когда его использовать:

• Когда у вас есть гарантии времени выполнения, которые компилятор не может проанализировать
• В сценариях, как в вашем примере, где инициализация происходит через взаимодействие с пользователем
• В модульных тестах, где вы уже убедились, что объект не равен null

Важные замечания:

• Оператор не оказывает влияния во время выполнения - он влияет только на статический анализ компилятора
• Его следует использовать умеренно и с соответствующей документацией
• В блоге Мэтью Чэмпиона предупреждается, что “Оператор ‘прощения null’ в C# - это запах кода” при чрезмерном использовании

Для вашего конкретного сценария с static string[]? foodItems использование foodItems!.Contains("cookie") уместно, когда вы установили, что инициализация определенно произойдет перед операцией поиска.

Атрибут MemberNotNullWhen

Атрибут MemberNotNullWhen обеспечивает более структурированный подход к передаче информации о нулевом состоянии компилятору. Как описано в статье в блоге Халида Абуахмеха, вы можете украшать булевы свойства или методы, возвращающие bool, этим атрибутом.

public class FoodManager
{
    public static string[]? FoodItems { get; private set; }
    
    [MemberNotNullWhen(true, nameof(FoodItems))]
    public static bool IsInitialized => FoodItems is not null;
    
    public static void Initialize()
    {
        FoodItems = GetFoodItemsFromUser();
    }
    
    public static bool SearchFood(string item)
    {
        if (!IsInitialized)
        {
            // Это указывало бы на ошибку в потоке программы
            throw new InvalidOperationException("FoodItems не инициализирован");
        }
        
        return FoodItems.Contains(item);
    }
}

Преимущества:

• Предоставляет четкую документацию о ожидаемом нулевом состоянии
• Позволяет лучше анализировать компилятором сложные сценарии
• Хорошо работает с анализом ссылочных типов nullable

Шаблоны проектирования для гарантированной инициализации

Несколько шаблонов проектирования могут помочь компилятору понять, что ваши ссылки будут правильно инициализированы:

1. Свойства с инициализатором

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

public class FoodManager
{
    public static string[] FoodItems { get; init; }
    
    public static void Initialize()
    {
        FoodItems = GetFoodItemsFromUser();
    }
}

2. Инициализация в конструкторе

Для полей экземпляров убедитесь, что они инициализированы в конструкторе:

public class FoodManager
{
    private string[] _foodItems;
    
    public FoodManager()
    {
        _foodItems = Array.Empty<string>(); // Начинаем с пустого массива
    }
    
    public void InitializeFromUserInput()
    {
        _foodItems = GetFoodItemsFromUser();
    }
}

3. Ленивая инициализация

Для сценариев, где инициализация дорогая или отложенная:

public class FoodManager
{
    private static Lazy<string[]> _foodItems = new Lazy<string[]>(() => 
    {
        return GetFoodItemsFromUser();
    });
    
    public static string[] FoodItems => _foodItems.Value;
}

Конфигурация компилятора и параметры проекта

Правильная конфигурация компилятора может значительно улучшить анализ ссылочных типов nullable:

Параметры контекста nullable

В вашем файле .csproj вы можете настроить контекст nullable:

<PropertyGroup>
    <Nullable>enable</Nullable>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
</PropertyGroup>

Глобальный файл подавления предупреждений

Для легитимных случаев, когда вам нужно подавлять предупреждения во множестве файлов, рассмотрите глобальный файл подавления:

// GlobalSuppressions.cs
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Nullable", "CS8618:Non-nullable field must contain a non-null value when exiting constructor.")]

Лучшие практики и рекомендации

На основе результатов исследований и конкретного сценария, который вы описали, вот рекомендуемые подходы:

1. Для вашего конкретного сценария (статическое поле с инициализацией, инициируемой пользователем)

static string[]? foodItems = null;

// Когда вы знаете, что инициализация произошла:
public static void SearchFood(string item)
{
    if (foodItems == null)
    {
        throw new InvalidOperationException(
            "FoodItems не инициализирован - это указывает на ошибку в потоке программы");
    }
    
    return foodItems.Contains(item);
}

Почему этот подход:

• Обеспечивает безопасность времени выполнения для неожиданных случаев null
• Четко документирует ожидание, что инициализация должна была произойти
• Выбрасывает исключение, как вы указали, что уместно для ошибок в потоке программы
• Более поддерживаемый, чем оператор “прощения null”

2. Когда использовать оператор “прощения null”

Используйте !, когда:

• У вас есть внешняя проверка, которую компилятор не может видеть
• Нулевое состояние четко установлено предшествующим кодом
• Вы находитесь в строго контролируемом сценарии, таком как модульные тесты после Assert.NotNull
• Вы работаете с преобразованием устаревшего кода

// Пример модульного теста
[Fact]
public void TestFoodSearch()
{
    var manager = new FoodManager();
    manager.InitializeTestItems();
    
    // Мы знаем, что он не равен null после инициализации
    var result = manager.TestItems!.Contains("cookie");
    Assert.True(result);
}

3. Когда использовать атрибут MemberNotNullWhen

Используйте этот атрибут, когда:

• У вас есть сложная логика инициализации
• Вы хотите предоставить четкую документацию о нулевом состоянии
• Вы работаете с несколькими связанными свойствами, которые нужно инициализировать вместе

Альтернативные подходы

Ручные проверки на null с пользовательскими типами исключений

Для сценариев, где null указывает на ошибку в потоке программы:

public static class Guard
{
    public static void AgainstNull<T>(T? value, string paramName) where T : class
    {
        if (value == null)
        {
            throw new ProgramInitializationException(
                $"{paramName} не был инициализирован перед использованием. Это указывает на ошибку в потоке программы.");
        }
    }
}

// Использование
public static bool SearchFood(string item)
{
    Guard.AgainstNull(foodItems, nameof(foodItems));
    return foodItems.Contains(item);
}

Шаблон Null Object

Рассмотрите использование шаблона null object, если он подходит для вашей предметной области:

public static class FoodManager
{
    private static string[]? _foodItems;
    
    // Возвращаем пустой массив вместо null
    public static string[] FoodItems => _foodItems ?? Array.Empty<string>();
}

Это устраняет состояние null полностью, сохраняя тот же API.

Источники

1. Оператор “прощения null” - Справочник по C# | Microsoft Learn
2. Оператор “прощения null” в C# - это запах кода(!) – Matthew Champion
3. Как исправить предупреждения о nullable в .NET для защищенных членов | Khalid Abuhakmeh
4. Устранение предупреждений о nullable - Справочник по C# | Microsoft Learn
5. Ссылочные типы nullable - C# | Microsoft Learn
6. r/csharp на Reddit: Кто-нибудь знает, как удалить эти предупреждения о нулевой ссылке?
7. c# - Какой рекомендуемый способ обработки ситуаций, когда ссылки могут быть null, но если они null, программа все равно фундаментально неисправна? - Stack Overflow

Заключение

Для вашего конкретного сценария с static string[]? foodItems рекомендуемым подходом является реализация ручной проверки на null с описательным исключением, которое четко указывает, что это представляет собой ошибку в потоке программы, а не восстанавливаемое условие времени выполнения. Это обеспечивает как безопасность времени выполнения, так и четкую документацию вашего намерения.

Ключевые рекомендации:

1. Избегайте чрезмерного использования оператора “прощения null” - Хотя это и удобно, он может скрывать важную информацию о нулевом состоянии
2. Используйте атрибуты MemberNotNullWhen для сложных сценариев инициализации, чтобы помочь компилятору понять нулевое состояние
3. Проектируйте для гарантированной инициализации через правильное использование конструкторов, свойств с инициализатором или ленивой инициализации
4. Предоставляйте четкие сообщения об ошибках при указании на ошибки в потоке программы
5. Рассмотрите шаблон null object для полного устранения состояний null, если это уместно

Лучший подход балансирует предупреждения компилятора с безопасностью времени выполнения, обеспечивая, что ваш код как поддерживаемый, так и устойчив к неожиданным состояниям null, при этом предоставляя четкую документацию ваших гарантий инициализации.