! Opérateur ! (null-indulgent) (référence C#)

L’opérateur postfix ! unaire est l’opérateur null-forgiving ou null-suppression. Dans un contexte d’annotation nullable activé, vous utilisez l’opérateur null-forgiving pour supprimer tous les avertissements nullables pour l’expression précédente. L’opérateur de préfixe ! unaire est l’opérateur de négation logique. L’opérateur null-forgiving n’a aucun effet au moment de l’exécution. Elle affecte uniquement l’analyse de flux 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 xsous-jacente .

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

Exemples

L’un des cas d’usage de l’opérateur null-forgiving concerne le test de 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-forgiving, 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-forgiving, vous informez le compilateur que le passage null est attendu et ne doit pas être averti.

Vous pouvez également utiliser l’opérateur null-forgiving quand vous savez certainement qu’une expression ne peut pas l’être null , mais que le compilateur ne parvient pas à le reconnaître. Dans l’exemple suivant, si la IsValid méthode retourne true, son argument n’est pas null et vous pouvez le 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-forgiving, 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-forgiving, car le compilateur dispose de suffisamment d’informations pour découvrir qu’il p ne peut pas se trouver null à l’intérieur de l’instruction if . 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 des 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-forgiving du brouillon de la spécification des types de référence nullables.

Voir aussi