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

  • Article

L’opérateur unaire suffixé ! est l’opérateur null-forgiving, ou null-suppression. Lorsque l’annotation pouvant accepter la valeur Null est activée, l’opérateur null-forgiving vous permet de supprimer tous les avertissements pouvant accepter la valeur Null pour l’expression précédente. L’opérateur unaire suffixé ! est l’opérateur de négation logique. L’opérateur null-forgiving n’a aucun effet au moment de l’exécution. Il affecte uniquement l’analyse du flux statique du compilateur en modifiant l’état Null de l’expression. Au moment de l’exécution, l’expression x! correspond au résultat de l’expression x sous-jacente .

Pour plus d’informations sur la fonctionnalité des types référence pouvant accepter la valeur Null, consultez Types référence pouvant accepter la valeur Null.

Exemples

Le test de la logique de validation des arguments est l’un des cas d’usage de l’opérateur null-forgiving. 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; }
}

Utilisez l’infrastructure de test MSTest afin de 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. Avec l’opérateur null-forgiving, vous informez le compilateur que le passage de null est attendu et ne doit pas faire l’objet d’un avertissement.

Vous pouvez également utiliser l’opérateur null-forgiving lorsque vous savez pertinemment qu’une expression ne peut pas être null mais que le compilateur ne parvient pas à le reconnaître. Dans l’exemple suivant, si la méthode IsValid renvoie 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 code p.Name : Warning CS8602: Dereference of a possibly null reference.

Si vous pouvez modifier la méthode IsValid, utilisez l’attribut NotNullWhen pour informer le compilateur qu’un argument de la méthode IsValid ne peut pas être null lorsque la méthode renvoie 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, il n’est pas nécessaire d’utiliser l’opérateur null-forgiving, car le compilateur dispose d’informations suffisantes pour savoir que p ne peut pas être null dans 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 les API avec des attributs pour définir les attentes en matière de valeurs Null.

spécification du langage C#

Pour plus d’informations, consultez la section L’opérateur null-forgiving du projet de spécification sur les types référence pouvant accepter la valeur Null.

Voir aussi