Les rejets et le motif de rejet

Tip

Cet article fait partie de la section Notions de base pour les développeurs qui connaissent déjà au moins un langage de programmation et apprennent C#. Si vous débutez avec les modèles, commencez par la vue d’ensemble des critères correspondants. Pour obtenir une syntaxe complète, consultez la référence du modèle d’abandon.

Le jeton de soulignement (_) indique qu’une valeur n’est pas nécessaire. Sa signification exacte dépend de l’emplacement où elle apparaît :

Context Signification de _
Une branche d’une expression switch ou un motif imbriqué Modèle d’abandon qui correspond sans capturer le résultat
Déconstruction ou out argument Une variable de rejet qui ignore une valeur produite
Une assignation telle que _ = expression Affectation d’abandon qui évalue l’expression et ignore son résultat
Deux paramètres lambda ou plus nommés _ Ignorer les paramètres dont les entrées ne sont pas utilisées
var _ dans un motif Modèle var avec une désignation d’abandon

Ces formulaires partagent l’orthographe et l’intention, mais ils ne sont pas interchangeables.

Utilisation des critères spéciaux avec switch

Dans l’exemple suivant, statusCode est un int. Chaque bras de commutateur produit un string message, que le programme écrit dans la console. La dernière _ gère chaque code d’état autre que 200 et 404:

static void ShowStatus()
{
    int statusCode = 503;
    string message = statusCode switch
    {
        200 => "Ready",
        404 => "Not found",
        _ => "Another status"
    };

    Console.WriteLine(message);
}

Un motif de rejet est appliqué à une expression en entrée. C# évalue l’expression et _ correspond à la valeur évaluée sans la capturer. Choisissez _ comme branche finale de l’expression switch lorsque chaque valeur qui n’a pas été traitée auparavant doit utiliser la même solution de repli. Mettez-le en dernier parce qu’il correspond à tout, y compris null.

La forme var _ correspond à un motif var avec une désignation de rejet. Elle correspond également à chaque valeur évaluée, mais elle n’introduit pas de variable lisible. Préférez le motif de suppression _ plus court pour un cas par défaut dans un switch. Pour plus d’informations sur var les modèles et les désignations, consultez Déclaration, constante et var modèles.

Déclarations de déconstruction

GetForecast retourne un tuple avec quatre composants : une string ville et trois int valeurs pour la température élevée, la basse température et la probabilité de pluie. La déclaration de déconstruction conserve city et high parce que le programme les affiche. Il utilise _ pour la température basse et la probabilité de pluie, car donner un nom à ces composants inutilisés laisserait entendre que le code en a besoin :

static void ShowForecast()
{
    var (city, high, _, _) = GetForecast();
    Console.WriteLine($"{city}: high {high}°C");

    static (string City, int High, int Low, int RainChance) GetForecast() =>
        ("Portland", 18, 9, 40);
}

La même syntaxe de rejet fonctionne lorsque la méthode Deconstruct d’un objet produit plusieurs valeurs. Pour ces formes, voir Déconstruire des tuples et d’autres types.

Appels aux méthodes avec un paramètre out

Supposons qu’un champ d’entrée accepte le texte uniquement lorsqu’il représente un nombre entier. La TryParse(String, Int32) méthode retourne un bool rapport indiquant si l’analyse a réussi. Il génère également le contenu analysé int via son paramètre out. Le code suivant a uniquement besoin du résultat booléen pour accepter ou rejeter l’entrée :

static void CheckInput()
{
    string text = "42";

    if (IsWholeNumber(text))
    {
        Console.WriteLine($"Accepted: {text}");
    }
    else
    {
        Console.WriteLine("Enter a whole number.");
    }

    static bool IsWholeNumber(string text) => int.TryParse(text, out _);
}

Utilisez out _ quand seule la réussite de l’opération est importante. L’abandon indique clairement que le nombre analysé n’est pas nécessaire. Si le code ultérieur a besoin du nombre, donnez à l’argument out un nom, par out int numberexemple, et conservez cette valeur à la place.

Une affectation d’abandon, évalue _ = expressionune expression et ignore intentionnellement son résultat. Cela peut parfois être utile lorsque l’expression ne constitue pas autrement une instruction valide.

Important

N’utilisez pas _ = Task.Run(...) ou _ = SomeAsyncMethod() pour abandonner une tâche dans le code de l’application. Attendez que la tâche se termine afin que son exécution et ses exceptions restent dans le flux de l’appelant. Une affectation de rejet ne permet pas de rendre une tâche sûre, d’observer son exception ou de créer une opération « fire-and-forget » prise en charge.

Marquer les paramètres lambda inutilisés

Un EventHandler reçoit un object? expéditeur et une valeur EventArgs. Le gestionnaire suivant n’a pas besoin d’un paramètre ; il écrit "Timer tick" uniquement dans la console. Le nommage des deux paramètres _ rend leur état inutilisé visible sans inventer de noms que le corps n’utilise jamais :

static void ShowLambdaDiscards()
{
    EventHandler handler = (_, _) => Console.WriteLine("Timer tick");
    handler(null, EventArgs.Empty);
}

Choisissez ignorer les paramètres lorsqu’une signature de délégué nécessite des entrées que le corps lambda n’utilise pas. Si un lambda n’a qu’un seul paramètre nommé _, _ reste un nom de paramètre ordinaire pour la compatibilité descendante.

Éviter _ en tant qu’identificateur

_ peut être un identificateur ordinaire dans les contextes où C# ne reconnaît pas d’abandon. Une variable de portée appelée _ peut se voir affecter une valeur qui ressemble à une affectation à une variable de rejet. Dans un contexte de motif, une constante ou un type accessible nommé _ peut également modifier la façon dont _ est interprété. Évitez de déclarer vos propres variables, constantes ou types nommés _; utilisez _ pour communiquer l’intention d’abandon.

Voir aussi

  • Last updated on