Partage via

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

L’opérateur unaire suffixé ! est l’opérateur null-forgiving, ou null-suppression. Dans un contexte d’annotation nullable activé, utilisez l’opérateur null-forgiving pour supprimer tous les avertissements nullables 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.

La documentation de référence du langage C# décrit la version la plus récente du langage C#. Il contient également la documentation initiale des fonctionnalités dans les préversions publiques pour la prochaine version du langage.

La documentation identifie toute fonctionnalité introduite en premier dans les trois dernières versions de la langue ou dans les préversions publiques actuelles.

Conseil / Astuce

Pour savoir quand une fonctionnalité a été introduite en C#, consultez l’article sur l’historique des versions du langage C#.

Exemples

Un cas d’usage pour l’opérateur null-forgiving teste 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 générer d’avertissement.

Vous pouvez également utiliser l’opérateur null-forgiving lorsque vous savez certainement qu’une expression ne peut pas être null , mais que le compilateur ne le reconnaît pas. 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

  • Last updated on