Déclaration, constante et var modèles

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#. Commencez par la vue d’ensemble des critères correspondants si vous n’avez pas déjà utilisé de modèles C#. Pour obtenir des règles de langage complètes, consultez la référence des modèles.

Un modèle est appliqué à une expression d’entrée. C# évalue l’expression, puis le modèle teste ou capture la valeur résultante. La déclaration, la constante et les patrons var répondent à trois questions pratiques :

  • Modèle de déclaration : L’expression a-t-elle produit une valeur non Null d’un type d’exécution compatible ? Si c’est le cas, déclarez une variable pour cette valeur.
  • Modèle constant : L’expression a-t-elle produit une valeur constante spécifique ?
  • var modèle : Quelle valeur l’expression a-t-elle produite ? Capturez-le sans tester d’abord son type ou sa valeur.

Tester et capturer un type avec un modèle de déclaration

Un modèle de déclaration se compose d’un type et d’une désignation. Le type spécifie le type d’exécution à tester. La désignation déclare la variable qui reçoit la valeur correspondante.

L’exemple suivant reçoit un object, de sorte que l’expression peut produire de nombreux types différents. Le modèle de déclaration permet à la branche correspondante d’utiliser un montant décimal sans test de type séparé ni conversion de type :

static void PrintPrice(object value)
{
    if (value is decimal amount)
    {
        Console.WriteLine($"Price: {amount:C}");
    }
}

Dans value is decimal amount :

  • value est l’expression d’entrée. C# l’évalue d’abord.
  • decimal est le type testé. Le modèle correspond lorsque la valeur évaluée n’est pas null et que son type d’exécution est compatible avec decimal.
  • amount est la désignation. Lorsque le modèle correspond, il déclare amount et lui affecte la valeur décimale.

Le compilateur suit si une variable locale reçoit une valeur avant que votre code ne le lise. Ce suivi est appelé affectation définitive. À l’intérieur du bloc if, le compilateur sait que amount s’est vu attribuer une valeur, car le bloc ne s’exécute que lorsque le motif correspond. Le compilateur génère une erreur si votre code tente d’accéder amount en dehors du if bloc. Si value ce n’est pas une decimal valeur, la variable amount n’est pas affectée à une valeur.

Choisissez un modèle de déclaration lorsque la branche correspondante doit utiliser le résultat comme type testé. Il combine la déclaration de test, de conversion et de variable, ce qui évite de répéter l’expression ou d’écrire un cast distinct.

Vous pouvez également utiliser des modèles de déclaration quand une expression peut produire plusieurs types utiles :

static string FormatSensorValue(object reading) =>
    reading switch
    {
        int count => $"Count: {count}",
        double temperature => $"Temperature: {temperature:F1}°C",
        string message => $"Message: {message}",
        _ => "Unsupported reading"
    };

Chaque bras déclare une variable du type correspondant, car le résultat nécessite le comportement de formatage propre à ce type. Un modèle de déclaration correspond uniquement lorsque la valeur évaluée n’est pas null et a déjà un type d’exécution compatible avec le type testé via les conversions autorisées pour les modèles. null n’a pas de type d’exécution pour que le modèle corresponde. Le modèle n’exécute pas non plus d’opérateurs de conversion définis par l’utilisateur : il s’agit d’un test de type et d’une capture, et non d’une requête pour convertir la valeur en un autre type. Pour connaître les règles de compatibilité complètes, consultez Les modèles de déclaration et de type.

Mettre en correspondance une valeur spécifique avec un modèle constant

Un modèle constant teste si une expression produit une constante particulière, telle qu’un nombre, une chaîne, un membre booléen, un membre d’énumération, une valeur déclarée const ou null.

Les modèles constants correspondent à une expression de commutateur lorsque plusieurs valeurs connues produisent chacun un résultat différent :

static string GetCommandMessage(Command command) =>
    command switch
    {
        Command.Start => "Starting",
        Command.Stop => "Stopping",
        Command.Pause => "Pausing",
        _ => "Unknown command"
    };

Command est une énumération, un type qui définit un ensemble de constantes nommées. Command.Start, Command.Stopet Command.Pause sont ses membres d’énumération, de sorte que chaque bras de commutateur utilise un modèle constant pour tester une valeur de commande nommée.

Choisissez ce formulaire lorsque la commande peut avoir plusieurs significations discrètes. Les branches de l’instruction switch gardent les valeurs et leurs résultats regroupés. Pour un simple test d’égalité, une instruction if, telle que if (command == Command.Start), est généralement plus facile à lire.

Le filtrage par motif constant utilise les règles d’égalité intégrées au langage plutôt qu’un opérateur == défini par l’utilisateur. Pour obtenir les règles d’égalité et de conversion détaillées, consultez la référence de modèle constant.

Le null modèle constant est utile pour une vérification null fiable :

static bool HasText(string? text) => text is not null;

Choisissez is null ou is not null lorsque vous vérifiez l’état Null. Ces motifs n’appellent pas d’opérateur d’égalité défini par l’utilisateur, même lorsque le type de l’expression surcharge ==.

Capturer un résultat pour un garde avec un var modèle

Un var modèle correspond à chaque résultat, y compris nullet déclare une variable dont le type est le type de compilation de l’expression d’entrée. Il peut capturer une valeur calculée alors qu’un autre modèle correspond déjà à un objet :

static string GetDeliveryMessage(object delivery) =>
    delivery switch
    {
        ExpressDelivery express
            when EstimateDays(express) is var days && days <= 2
                => $"Arrives in {days} day{(days == 1 ? "" : "s")}",
        ExpressDelivery => "Express delivery for your location takes more than two days",
        _ => "Standard delivery"
    };

static int EstimateDays(ExpressDelivery delivery) =>
    delivery.MilesAway <= 500 ? 1 :
    delivery.MilesAway <= 1_000 ? 2 : 3;

record ExpressDelivery(int MilesAway);

Le modèle ExpressDelivery express de déclaration capture d’abord l’objet de remise en tant que express. L’appel EstimateDays(express) de méthode est l’expression d’entrée du var modèle. C# évalue cet appel de méthode et var days capture l’estimation résultante comme days sans tester son type ou sa valeur. L’estimation peut être d’un ou deux jours lorsque la garde réussit. Le résultat du bras a besoin de la valeur capturée pour signaler le nombre réel de jours.

Une variable locale ordinaire ne peut pas être déclarée entre un modèle de commutateur et sa when garde. Rappeler EstimateDays(express) dans le résultat répéterait le calcul. Choisissez ce var formulaire de modèle lorsque le code correspond déjà, et que la protection et le résultat ont besoin d’une valeur intermédiaire calculée.

Si vous n’avez pas besoin de la valeur capturée, utilisez le modèle _d’abandon au lieu de déclarer une variable.

Voir aussi

  • Last updated on