! (null-indulgent avec), opérateur (référence C#)

Disponible en C# 8,0 et versions ultérieures, l’opérateur postfix unaire ! est l’opérateur null-indulgent avec, ou suppression de valeur null. Dans un contexte d’annotation Nullableactivé, vous utilisez l’opérateur null-indulgent avec pour déclarer que l’expression x d’un type référence n’est pas null : x! . L’opérateur préfixé unaire ! est l' opérateur de négation logique.

L’opérateur null-indulgent avec n’a aucun effet au moment de l’exécution. Elle affecte uniquement l’analyse du déroulement statique du compilateur en modifiant l’État null de l’expression. Au moment de l’exécution, l’expression x! prend la valeur du résultat de l’expression sous-jacente x .

Pour plus d’informations sur la fonctionnalité des types de référence Nullable, consultez types de référence Nullable.

Exemples

L’un des cas d’usage de l’opérateur null-indulgent avec consiste à tester la logique de validation d’argument. Par exemple, considérons la classe suivante :

#nullable enable
public class Person
{
    public Person(string name) => Name = name ?? throw new ArgumentNullException(nameof(name));

    public string Name { get; }
}

À l’aide de l' infrastructure de test MSTest, vous pouvez créer le test suivant pour la logique de validation dans le constructeur :

[TestMethod, ExpectedException(typeof(ArgumentNullException))]
public void NullNameShouldThrowTest()
{
    var person = new Person(null!);
}

Sans l’opérateur null-indulgent avec, le compilateur génère l’avertissement suivant pour le code précédent : Warning CS8625: Cannot convert null literal to non-nullable reference type . En utilisant l’opérateur null-indulgent avec, vous informez le compilateur que le passage null est attendu et ne doit pas être averti de.

Vous pouvez également utiliser l’opérateur null-indulgent avec lorsque vous savez absolument qu’une expression ne peut pas être, null mais que le compilateur ne gère pas. Dans l’exemple suivant, si la IsValid méthode retourne true , son argument n’est pas null et vous pouvez la déréférencer en toute sécurité :

public static void Main()
{
    Person? p = Find("John");
    if (IsValid(p))
    {
        Console.WriteLine($"Found {p!.Name}");
    }
}

public static bool IsValid(Person? person)
    => person is not null && person.Name is not null;

Sans l’opérateur null-indulgent avec, le compilateur génère l’avertissement suivant pour le p.Name Code : Warning CS8602: Dereference of a possibly null reference .

Si vous pouvez modifier la IsValid méthode, vous pouvez utiliser l’attribut NotNullWhen pour informer le compilateur qu’un argument de la IsValid méthode ne peut pas être null lorsque la méthode retourne true :

public static void Main()
{
    Person? p = Find("John");
    if (IsValid(p))
    {
        Console.WriteLine($"Found {p.Name}");
    }
}

public static bool IsValid([NotNullWhen(true)] Person? person)
    => person is not null && person.Name is not null;

Dans l’exemple précédent, vous n’avez pas besoin d’utiliser l’opérateur null-indulgent avec, car le compilateur dispose de suffisamment d’informations pour déterminer qu’il p ne peut pas se trouver null à l’intérieur de l' if instruction. Pour plus d’informations sur les attributs qui vous permettent de fournir des informations supplémentaires sur l’État null d’une variable, consultez mettre à niveau les API avec des attributs pour définir des attentes null.

spécification du langage C#

Pour plus d’informations, consultez la section opérateur null-indulgent avec du brouillon de la spécification des types de référence Nullable.

Voir aussi