Expressions

Une expression est une séquence d'un ou plusieurs opérandes et de zéro, un ou plusieurs opérateurs qui peuvent être évalués à une valeur, un objet, une méthode ou un espace de noms unique. Elle peut être constituée d'une valeur littérale, d'un appel de méthode, d'un opérateur et de ses opérandes, ou d'un nom simple. Un nom simple peut être le nom d'une variable, d'un membre de type, d'un paramètre de méthode, d'un espace de noms ou d'un type.

Les expressions peuvent utiliser des opérateurs qui à leur tour utilisent d'autres expressions en tant que paramètres, ou des appels de méthode dont les paramètres sont à leur tour d'autres appels de méthode. Leur complexité est donc très variable. Voici deux exemples d'expressions :

Valeurs d'expressions

Dans la plupart des contextes dans lesquels les expressions sont utilisées, par exemple dans les instructions ou les paramètres de méthode, l'expression est supposée correspondre à une valeur. Si x et y sont des entiers, l'expression x + y correspond à une valeur numérique. L'expression new MyClass() correspond à une référence à une nouvelle instance d'une classe MyClass. L'expression myClass.ToString() correspond à une chaîne, car c'est le type de retour de la méthode. Toutefois, même si un espace de noms est considéré comme une expression, il ne correspond pas à une valeur et ne peut donc jamais être le résultat final d'une expression. Vous ne pouvez pas passer un nom d'espace de noms à un paramètre de méthode, ni l'utiliser dans une nouvelle expression ou l'affecter à une variable. Vous pouvez l'utiliser uniquement en tant que sous-expression dans une expression plus longue. Il en va de même pour les types (par opposition aux objets System.Type), aux noms de groupes de méthodes (par opposition aux méthodes spécifiques) et aux accesseurs d'événements add et remove.

Chaque valeur possède un type associé. Par exemple, si x et y sont toutes deux des variables de type int, la valeur de l'expression x + y est également de type int. Si la valeur est assignée à une variable d'un type différent, ou si x et y sont des types différents, les règles de conversion de type sont appliquées.

Dépassements de capacité

Les expressions numériques peuvent provoquer des dépassements de capacité si la valeur est supérieure à la valeur maximale du type de la valeur. Pour plus d'informations, consultez Checked et Unchecked.

Priorité des opérateurs et associativité

Le mode d'évaluation de l'expression est régi par les règles de priorité des opérateurs et d'associativité. La plupart des expressions, sauf les expressions d'assignation et les expressions d'appel de méthode, doivent être incorporées dans une instruction.

Littéraux et noms simples

Les deux types d'expressions les plus simples sont les littéraux et les noms simples. Un littéral est une valeur constante qui n'a aucun nom. Par exemple, dans l'exemple de code suivant, 5 et "Hello World" sont des valeurs littérales :

Dans l'exemple précédent, i et s sont des noms simples qui identifient des variables locales. Quand ces variables sont utilisées dans une expression, le nom de la variable prend la valeur qui est stockée actuellement à l'emplacement de la variable en mémoire. Ceci est illustré dans l'exemple suivant :

Appel d'expressions

Dans l'exemple de code suivant, l'appel à DoWork est une expression d'appel.

Un appel de méthode nécessite le nom de la méthode, soit comme nom (comme dans l'exemple précédent), soit comme le résultat d'une autre expression, suivi de parenthèses et des éventuels paramètres de méthode. Un appel de délégué utilise le nom d'un délégué et des paramètres de méthode entre parenthèses. Les appels de méthode et les appels de délégué sont évalués à la valeur de retour de la méthode, si celle-ci retourne une valeur. Les méthodes qui retournent void ne peuvent pas être utilisées à la place d'une valeur dans une expression.

Expressions de requête

Les mêmes règles relatives aux expressions s'appliquent en général aux expressions de requête. Pour plus d'informations, consultez Expressions de requête LINQ.

Expressions lambda

Les expressions lambda représentent des "méthodes inline" qui n'ont aucun nom mais qui peuvent avoir des paramètres d'entrée et plusieurs instructions. Elles sont largement utilisées dans LINQ pour passer des arguments aux méthodes. Les expressions lambda sont compilées en délégués ou en arborescences de l'expression en fonction du contexte dans lequel elles sont utilisées.

Arborescences de l'expression

Les arborescences de l'expression permettent de représenter des expressions en tant que structures de données. Elles sont largement utilisées par les fournisseurs LINQ pour traduire des expressions de requête en code explicite dans un autre contexte, comme une base de données SQL.

Définitions de corps d'expression

C# prend en charge les membres expression-bodied, qui vous permettent de fournir une définition de corps d'expression concise pour des méthodes, des constructeurs, des finaliseurs, des propriétés et des indexeurs.

Membres expression-bodied

Les définitions de corps d'expression vous permettent de fournir l'implémentation d'un membre sous une forme lisible et très concise. Vous pouvez utiliser une définition de corps d'expression chaque fois que la logique d'un membre pris en charge, comme une méthode ou une propriété, se compose d'une seule expression. La syntaxe générale d'une définition de corps d'expression est la suivante :

où expression est une expression valide.

La prise en charge des définitions de corps d'expression a été introduite pour les méthodes et les propriétés en lecture seule dans C# 6 et a été étendue dans C# 7.0. Vous pouvez utiliser des définitions de corps d'expression avec les membres de type listés dans le tableau suivant :

Membre	Prise en charge à compter de
Méthode	C# 6
Propriété en lecture seule	C# 6
Property	C# 7.0
Constructeur	C# 7.0
Finaliseur	C# 7.0
Indexeur	C# 7.0

Méthodes

Une méthode expression-bodied se compose d'une seule expression qui retourne une valeur dont le type correspond au type de retour de la méthode ou, pour les méthodes qui retournent void, qui effectue une opération. Par exemple, les types qui substituent la méthode ToString incluent généralement une expression unique qui retourne la représentation sous forme de chaîne de l'objet actuel.

L'exemple suivant définit une classe Person qui substitue la méthode ToString avec une définition de corps d'expression. Il définit également une méthode DisplayName qui affiche un nom sur la console. Notez que le mot clé return n'est pas utilisé dans la définition de corps d'expression ToString.

Propriétés en lecture seule

Depuis C# 6, vous pouvez utiliser une définition de corps d'expression pour implémenter une propriété en lecture seule. Pour ce faire, utilisez la syntaxe suivante :

L'exemple suivant définit une classe Location dont la propriété en lecture seule Name est implémentée comme une définition de corps d'expression qui retourne la valeur du champ privé locationName :

Propriétés

Depuis C# 7.0, vous pouvez utiliser des définitions de corps d'expression pour implémenter la propriété get et les accesseurs set. L'exemple suivant montre comment faire :

Constructeurs

Une définition de corps d'expression pour un constructeur se compose généralement d'une seule expression d'assignation ou d'un appel de méthode qui gère les arguments du constructeur ou qui initialise l'état de l'instance.

L'exemple suivant définit une classe Location dont le constructeur a un seul paramètre de chaîne nommé name. La définition de corps d'expression assigne l'argument à la propriété Name.

Finaliseurs

Une définition de corps d'expression pour un finaliseur contient généralement des instructions de nettoyage, telles que des instructions qui libèrent les ressources non managées.

L'exemple suivant définit un finaliseur qui utilise une définition de corps d'expression pour indiquer que le finaliseur a été appelé.

Indexeurs

Comme les propriétés, les accesseurs get et set d'un indexeur sont composés de définitions de corps d'expression si l'accesseur get est constitué d'une seule instruction qui retourne une valeur ou si l'accesseur set effectue une assignation simple.

L'exemple suivant définit une classe nommée Sports qui inclut un tableau String interne contenant les noms de plusieurs sports. Les accesseurs get et set de l'indexeur sont implémentés en tant que définitions de corps d'expression.