Que fait l'opérateur C# `null!` et quand devez-vous l'utiliser ?

La signification de l'instruction "null!" en C#

Comprendre l'opérateur "!"

C# 8.0 introduit des types de référence nullables, permettant un contrôle précis sur la nullité des variables et des types de référence. Lorsqu'il est appliqué à un type, l'opérateur "!" (également connu sous le nom d'"opérateur null ignore") modifie l'état de nullité du type de nullable à non nullable.

Utilisation de "null!"

L'instruction "null!" applique l'opérateur "!" à un littéral nul, indiquant que les valeurs nulles doivent être traitées comme non nullables. Cela remplace la nullité par défaut du littéral nul et force le compilateur à supposer que la valeur n'est pas nulle.

Utilisation typique

Considérez le code suivant :

public class Person
{
    public string? MiddleName; // 可空
    public string LastName = null!; // 不可空
}

Dans cet exemple, la propriété "MiddleName" est nullable, ce qui signifie qu'elle peut contenir des valeurs nulles. Cependant, la propriété « LastName » est marquée comme non nullable à l'aide de « null ! ». Cela signifie que le compilateur imposera que la propriété "LastName" ne contienne jamais la valeur null, même si la valeur null lui a été initialement attribuée.

Explication technique

À partir de C# 8.0, tous les types de référence ne sont pas nullables par défaut. L'opérateur "!" vous permet de remplacer ce paramètre, rendant ainsi les types nullables non nullables. En revanche, l'opérateur "?" rend un type non nullable.

À utiliser avec prudence

L'opérateur "null!" doit être utilisé avec prudence. Il remplace les contrôles de sécurité nuls du compilateur, qui peuvent masquer d'éventuelles exceptions de référence nulle au moment de l'exécution. Vous ne devez l'utiliser que si vous êtes sûr qu'une valeur nullable ne sera jamais nulle.

Alternatives

Dans la plupart des cas, il est préférable d'utiliser une alternative pour éviter d'utiliser l'opérateur "null!". Par exemple, vous pouvez utiliser des types nullables et l'opérateur de fusion nul, ou vérifier explicitement les valeurs nulles avant d'y accéder.

Quand utiliser "null!"

L'opérateur "null!" est utile dans certaines situations :

• Lorsque le compilateur ne peut pas détecter qu'une valeur nullable est en réalité non nullable.
• Lors de la migration d'un ancien code qui repose sur des types nullables.
• Dans certains cas, vous souhaitez ignorer les contrôles de nullité et gérer explicitement les valeurs nulles.
• Simulez des scénarios nuls dans des cas de test sans provoquer d'erreurs de compilation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!