Ce que vous regardez est un membre d'expression corporelle et non une expression lambda.
Lorsque le compilateur rencontre un membre de propriété doté d'un corps d'expression , il le convertit essentiellement en un getter comme celui-ci:
public int MaxHealth
{
get
{
return Memory[Address].IsValid ? Memory[Address].Read<int>(Offs.Life.MaxHp) : 0;
}
}
(Vous pouvez le vérifier par vous-même en injectant le code dans un outil appelé TryRoslyn .)
Les membres dotés d'une expression - comme la plupart des fonctionnalités C # 6 - ne sont que du sucre syntaxique . Cela signifie qu'ils ne fournissent pas de fonctionnalités qui n'auraient pas pu être obtenues autrement grâce aux fonctionnalités existantes. Au lieu de cela, ces nouvelles fonctionnalités permettent d'utiliser une syntaxe plus expressive et succincte
Comme vous pouvez le voir, les membres dotés d'une expression ont une poignée de raccourcis qui rendent les membres de propriété plus compacts:
- Il n'est pas nécessaire d'utiliser une
returninstruction car le compilateur peut déduire que vous souhaitez renvoyer le résultat de l'expression
- Il n'est pas nécessaire de créer un bloc d'instructions car le corps n'est qu'une expression
- Il n'est pas nécessaire d'utiliser le
getmot - clé car il est impliqué par l'utilisation de la syntaxe des membres avec corps d'expression.
J'ai mis le dernier point en gras, car il est pertinent pour votre question actuelle, à laquelle je vais répondre maintenant.
La différence entre...
// expression-bodied member property
public int MaxHealth => x ? y:z;
Et...
// field with field initializer
public int MaxHealth = x ? y:z;
Est la même que la différence entre ...
public int MaxHealth
{
get
{
return x ? y:z;
}
}
Et...
public int MaxHealth = x ? y:z;
Ce qui - si vous comprenez les propriétés - devrait être évident.
Pour être clair, cependant: la première annonce est une propriété avec un getter sous le capot qui sera appelée chaque fois que vous y accéderez. La deuxième liste est un champ avec un initialiseur de champ, dont l'expression n'est évaluée qu'une seule fois, lorsque le type est instancié.
Cette différence de syntaxe est en fait assez subtile et peut conduire à un "gotcha" qui est décrit par Bill Wagner dans un article intitulé "AC # 6 gotcha: Initialization vs. Expression Bodied Members" .
Bien que les membres dotés d'une expression ressemblent à une expression lambda , ils ne sont pas des expressions lambda. La différence fondamentale est qu'une expression lambda aboutit à une instance déléguée ou à un arbre d'expression. Les membres dotés d'expressions ne sont qu'une directive adressée au compilateur pour générer une propriété en arrière-plan. La similitude (plus ou moins) commence et se termine par la flèche ( =>).
J'ajouterai également que les membres d'expression ne sont pas limités aux membres de propriété. Ils travaillent sur tous ces membres:
- Propriétés
- Indexeurs
- Les méthodes
- Les opérateurs
Ajouté dans C # 7.0
Cependant, ils ne fonctionnent pas sur ces membres:
- Types imbriqués
- Événements
- Des champs
