!! opérateur (null-forgiving) (référence C)(null-forgiving) operator (C# reference)

Disponible en C 8.0 et plus tard, l’opérateur de poteaufix ! nonary est l’opérateur nul-indulgent.Available in C# 8.0 and later, the unary postfix ! operator is the null-forgiving operator. Dans un contexte d’annotation annuléeactivé, vous utilisez l’opérateur nul pour déclarer que l’expression x d’un type de référence n’est pas null: x!.In an enabled nullable annotation context, you use the null-forgiving operator to declare that expression x of a reference type isn't null: x!. L’opérateur de ! préfixe nonaire est l’opérateur de négation logique.The unary prefix ! operator is the logical negation operator.

L’opérateur qui pardonne les nullités n’a aucun effet au moment de l’exécution.The null-forgiving operator has no effect at run time. Il n’affecte que l’analyse statique du flux du compilateur en modifiant l’état nul de l’expression.It only affects the compiler's static flow analysis by changing the null state of the expression. Au moment de x! l’exécution, l’expression xévalue au résultat de l’expression sous-jacente .At run time, expression x! evaluates to the result of the underlying expression x.

Pour plus d’informations sur la fonction de type de référence annulée, voir les types de référence Nullable.For more information about the nullable reference types feature, see Nullable reference types.

ExemplesExamples

L’un des cas d’utilisation de l’opérateur null-indulgent est de tester la logique de validation de l’argument.One of the use cases of the null-forgiving operator is in testing the argument validation logic. Par exemple, considérons la classe suivante :For example, consider the following class:

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

    public string Name { get; }
}

En utilisant le cadre de test MSTest, vous pouvez créer le test suivant pour la logique de validation dans le constructeur :Using the MSTest test framework, you can create the following test for the validation logic in the constructor:

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

Sans l’opérateur null-indulgent, le compilateur génère l’avertissement Warning CS8625: Cannot convert null literal to non-nullable reference typesuivant pour le code précédent: .Without the null-forgiving operator, the compiler generates the following warning for the preceding code: Warning CS8625: Cannot convert null literal to non-nullable reference type. En utilisant l’opérateur null-indulgent, vous informez null le compilateur que le passage est prévu et ne devrait pas être averti.By using the null-forgiving operator, you inform the compiler that passing null is expected and shouldn't be warned about.

Vous pouvez également utiliser l’opérateur null-indulgent quand vous null savez certainement qu’une expression ne peut pas être, mais le compilateur ne parvient pas à le reconnaître.You also can use the null-forgiving operator when you definitely know that an expression cannot be null but the compiler doesn't manage to recognize that. Dans l’exemple suivant, si la IsValid méthode revient, trueson argument n’est pas null et vous pouvez en toute sécurité le déreférencer:In the following example, if the IsValid method returns true, its argument is not null and you can safely dereference it:

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

public static bool IsValid(Person? person)
{
    return person != null && !string.IsNullOrEmpty(person.Name);
}

Sans l’opérateur null-indulgent, le compilateur génère l’avertissement suivant pour le p.Name code: Warning CS8602: Dereference of a possibly null reference.Without the null-forgiving operator, the compiler generates the following warning for the p.Name code: Warning CS8602: Dereference of a possibly null reference.

Si vous pouvez IsValid modifier la 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 revient true:If you can modify the IsValid method, you can use the NotNullWhen attribute to inform the compiler that an argument of the IsValid method cannot be null when the method returns 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)
{
    return person != null && !string.IsNullOrEmpty(person.Name);
}

Dans l’exemple précédent, vous n’avez pas besoin d’utiliser l’opérateur null-indulgent p parce null que if le compilateur a suffisamment d’informations pour savoir qui ne peut pas être à l’intérieur de la déclaration.In the preceding example, you don't need to use the null-forgiving operator because the compiler has enough information to find out that p cannot be null inside the if statement. Pour plus d’informations sur les attributs qui vous permettent de fournir des informations supplémentaires sur l’état nul d’une variable, voir Upgrade API avec des attributs pour définir les attentes nulles.For more information about the attributes that allow you to provide additional information about the null state of a variable, see Upgrade APIs with attributes to define null expectations.

spécification du langage C#C# language specification

Pour plus d’informations, voir La section de l’opérateur nul-indulgent de l’ébauche de la spécification des types de référence nuls.For more information, see The null-forgiving operator section of the draft of the nullable reference types specification.

Voir aussiSee also