Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C#

Types référence nullable et contexte #nullable

Les annotations string et string? expriment l’intention concernant null, tandis que l’analyse de flux du compilateur signale les usages risqués. Le contexte #nullable gère séparément les annotations et les avertissements ; il n’ajoute pas de vérifications à l’exécution.

Version : .NET 10; repository net10.0 and LangVersion=preview; feature versions require per-entry verification

Syntaxe

T value;
T? optional;
#nullable enable
#nullable disable
#nullable restore
#nullable enable annotations
#nullable disable warnings
#nullable restore warnings

Les types référence nullable ont été introduits dans C# 8.0 et ne nécessitent pas le mode preview dans un projet .NET 10. Lorsque les annotations sont activées, string désigne une référence qui, selon l’intention, ne devrait pas être null, tandis que string? autorise explicitement null. Ces annotations correspondent au même type à l’exécution ; elles ne sont pas équivalentes à Nullable<T> pour les types valeur tels que int?.

Le compilateur distingue l’annotation déclarée d’une valeur de son état de nullité dans l’analyse de flux. À l’entrée d’une méthode, il considère généralement, d’après les annotations, qu’un paramètre string n’est pas null et qu’un paramètre string? peut l’être. Cet état peut évoluer au cours de l’analyse de flux. Le compilateur signale l’affectation d’un null possible à une référence non nullable, ainsi que le déréférencement d’une référence potentiellement nulle, par exemple avec text.Length. Après avoir vérifié text is null et quitté cette branche, l’analyse reconnaît que l’utilisation suivante de text est sûre. L’opérateur text! ne fait que modifier l’évaluation du compilateur : il ne vérifie pas la valeur et n’empêche pas NullReferenceException.

Le réglage de projet <Nullable>enable</Nullable> active les annotations et les avertissements. disable désactive les deux, annotations active uniquement les annotations et warnings uniquement les avertissements. Lorsque les annotations sont désactivées, les références sans ? ne sont pas suivies du point de vue de la nullité, et l’utilisation de ? peut provoquer un avertissement.

Les directives #nullable enable et #nullable disable remplacent les réglages pour les lignes suivantes du fichier. #nullable restore rétablit les réglages du projet, et non la directive précédente. Une cible facultative, annotations ou warnings, comme dans #nullable disable warnings, ne modifie que le paramètre indiqué. L’effet dure jusqu’à une autre directive applicable ou jusqu’à la fin du fichier.

Il s’agit d’une aide à la compilation, pas d’une garantie contre null à l’exécution. Par exemple, new string[3] contient initialement des éléments null, malgré son type string[]. Corrigez le flux de données et vérifiez les valeurs plutôt que de supprimer aveuglément les avertissements avec !.

Identifiants de référence couverts par cette entrée : Nullable reference annotations and #nullable context.

Exemples

#nullable enable
using System;

internal static class Program
{
    private static void Main()
    {
        PrintLength(null);
        PrintLength("Ada");
    }

    private static void PrintLength(string? text)
    {
        if (text is null)
        {
            Console.WriteLine("missing");
            return;
        }

        Console.WriteLine(text.Length);
    }
}
#nullable restore

Résultat

missing
3

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources