Expressions en C# et F#
L'évaluateur d'expression managée accepte la plupart des expressions écrites en C#.
Toutefois, l'évaluateur d'expression managée ne reconnaît pas les expressions F#. Si vous déboguez F#, vous devez traduire vos expressions en syntaxe C# avant d'introduire les expressions dans une fenêtre du débogueur ou boîte de dialogue. Lorsque vous traduisez des expressions de F# à C#, assurez-vous de vous souvenir que C# utilise l'opérateur == pour tester pour l'égalité, tandis que F# utilise l'unique =.
Les sections suivantes fournissent des informations spécifiques et traitent de certains des types d'expressions qui ne sont pas pris en charge ou sont partiellement pris en charge :
Casts
Objets dynamiques
Identificateurs et types
Évaluation de méthode
Opérateurs
Opérateurs surchargés
Évaluation de propriété
Chaînes
Opérateurs typeof et sizeof
WebMethods
L'évaluateur d'expression ignore les modificateurs d'accès public, protected, internal et private . Vous pouvez appeler une méthode private depuis la fenêtre Espion, par exemple. Comme l'évaluateur d'expression ignore les modificateurs d'accès, il est possible d'appeler une charge inattendue.
L'évaluateur d'expression effectue toutes les évaluations dans un contexte unsafe implicite, que le code exécuté soit safe ou unsafe.
L'évaluateur d'expression ignore également les blocs vérifiés et l'option /checked du compilateur. Toutes les expressions sont évaluées dans un contexte non vérifié (unchecked).
Vous pouvez modifier à vote gré l'affichage de types de données personnalisés à l'aide d'attributs. Pour plus d'informations, consultez Affichage des types de données personnalisés.
Casts
Les expressions de cast simples fonctionnent dans le débogueur :
(A)x
Les casts qui impliquent des pointeurs ne fonctionnent pas dans le débogueur.
Objets dynamiques
L'évaluateur d'expression peut évaluer des variables qui sont typées statiquement comme dynamiques. Il peut également évaluer des objets qui implémentent l'interface IDynamicObject. Lorsque les objets qui implémentent l'interface IDynamicObject sont évalués dans la fenêtre Espion, un nœud Affichage dynamique est ajouté. Le nœud Affichage dynamique affiche les membres de l'objet mais n'autorise pas la modification des valeurs des membres.
Les fonctionnalités suivantes des objets dynamiques ne sont pas prises en charge :
Opérateurs composés +=, -=, %=, /= et *=
De nombreux casts, notamment les casts numériques et casts d'argument de type
Appels de méthode avec plus de deux arguments
Accesseurs Get de propriété comportant plus de deux arguments
Accesseurs Set de propriété comportant des arguments
Assignation à un indexeur
Les opérateurs booléens && et ||
Identificateurs et types
Les expressions du débogueur peuvent utiliser n'importe quel identificateur visible à l'intérieur de la portée actuelle. Si le débogueur est interrompu dans la méthode Magh, par exemple, vous pouvez utiliser n'importe quel identificateur visible dans Magh, y compris les constantes, les noms de variables et les noms de méthodes.
Le débogueur peut correctement afficher n'importe quelle variable de type primitif, énuméré ou intrinsèque. Pour les variables de type classe, le débogueur affiche correctement la valeur en fonction du type le plus dérivé. Si vous avez un objet leo de type Lion, dérivé du type Cat, vous pouvez évaluer leo.Claws et obtenir la valeur correcte pour un objet de type Lion.
Vous pouvez assigner une nouvelle valeur à toute expression de gauche qui a la valeur l. C'est le cas des types primitif, classe et System.Object.
Évaluation de méthode
Le débogueur prend en charge l'évaluation de méthodes, y compris les méthodes surchargées. Par conséquent, vous pouvez entrer l'une des expressions suivantes et le débogueur appellera la version correcte de la méthode surchargée :
Time.Set();
Time.Set(atime);
L'évaluation d'une méthode dans le débogueur appelle et exécute le code pour cette méthode. Si la méthode a des effets secondaires, l'évaluer dans une fenêtre du débogueur modifie l'état de votre programme, ce qui peut produire des résultats inattendus.
Lorsque vous définissez un point d'arrêt sur une méthode surchargée, l'emplacement du point d'arrêt dépend de la façon dont vous spécifiez la méthode. Si vous spécifiez la signature complète (nom de méthode et liste d'arguments complète), le débogueur définit un point d'arrêt sur la surcharge spécifiée. Si vous ne spécifiez que le nom de la méthode, le comportement du débogueur dépend d'un paramètre des options de Visual Studio. Si la case à cocher Utiliser IntelliSense pour vérifier le nom de la fonction est désactivée, le débogueur place un point d'arrêt sur chaque surcharge de ce nom de méthode. Sinon, la boîte de dialogue Choisir les points d'arrêt s'ouvre, dans laquelle vous pouvez spécifier sur quelle surcharge mettre le point d'arrêt. Pour plus d'informations, consultez Points d'arrêt : utiliser les nombres d'accès, les fonctions de la pile des appels et les conditions d'arrêt quand et où vous le voulez dans le débogueur Visual Studio.
Cette version de Visual Studio ne prend pas en charge la création de nouvelles méthodes anonymes dans le débogueur.
Opérateurs
Le débogueur évalue correctement la plupart des opérateurs intégrés, y compris :
Opérateurs relationnels et d'égalité: ( expr1> expr2, expr1< expr2, expr1<= expr2, expr1=> expr2, expr1== expr2, expr1!= expr2).
Opérateurs booléens: (expr1&& expr2, expr1|| expr2, expr1? expr2: expr3).
Opérateurs arithmétiques: (expr1+ expr2,expr1- expr2, expr1* expr2, expr1/ expr2, expr1% expr2 ).
Opérateurs logiques : (expr1& expr2, expr1^ expr2, expr1| expr2 ).
opérateurs de décalage: (expr1>> expr2, expr1<< expr2 ).
Opérateurs d'assignation: ( lvalue= expr2,lvalue*= expr2,lvalue/= expr2, lvalue%= expr2, lvalue+= expr2, lvalue-= expr2, lvalue<<= expr2, lvalue>>= expr2, lvalue&= expr2, lvalue^= expr2, lvalue|= expr2).
opérateurs unaires: ( +expr1, - expr1, expr1++, ++expr1, expr1--, --expr1).
Opérateurs surchargés
La plupart des opérateurs surchargés fonctionnent dans le débogueur.
Les opérateurs infix surchargés +, -, /, % et & fonctionnent.
expr1 + expr2
expr1 - expr2
expr1 / expr2
expr1 % expr2
expr1 & expr2
Les opérateurs infixes surchargés =, &&, &, et ||, ne fonctionnent pas :
expr1 = expr2
expr1 && expr2
expr1 & expr2
expr1 || expr2
Les opérateurs infix surchargés << et >> ne fonctionnent pas si les deux opérandes sont des variables de classe :
object1 <<object2
object1 >> object2
Les opérateurs de préfixe surchargés +, -, ++, --, ! et ~ fonctionnent :
+ expr1
- expr1
++ expr1
-- expr1
! expr1
~ expr1
Les opérateurs de suffixe surchargés ++ et -- fonctionnent :
expr1 ++
expr1 --
Les indexeurs surchargés fonctionnent :
- expr1 [ expr2 ]
Évaluation de propriété
Le débogueur peut évaluer les propriétés dans n'importe quelle fenêtre de variable. Cependant, l'évaluation d'une propriété dans le débogueur peut avoir des effets secondaires qui produisent des résultats inattendus et indésirables. Pour une protection contre les effets secondaires dus à une évaluation accidentelle, vous pouvez désactiver l'évaluation de propriété dans la boîte de dialogue Options.
Chaînes
Le débogueur reconnaît l'opérateur indexé lorsqu'il est utilisé avec des chaînes et des tableaux. Par exemple, vous pouvez entrer :
"hello world"[0]
La fenêtre Espion affiche la valeur correcte :
'h'
En C#, contrairement au C/C++ natif, vous pouvez modifier la valeur d'une chaîne dans le débogueur. De plus, vous pouvez utiliser l'opérateur Length dans une chaîne :
mystring.Length
ou
"hello world".Length
En C#, vous pouvez concaténer les chaînes :
"hello" + "world"
Opérateurs typeof et sizeof
Le débogueur prend en charge les opérateurs typeof et sizeof en les transformant en fonctions .NET Framework équivalentes.
typeof ( expression )
est transformé en :
System.Type.GetType( expression )
Le débogueur évalue ensuite cette expression transformée.
Le débogueur prend en charge l'opérateur sizeof.
WebMethods
Vous ne pouvez pas appeler de WebMethods à partir des fenêtres du débogueur.