Expressions en C#
Mise à jour : novembre 2007
Cette rubrique s'applique à :
Édition |
Visual Basic |
C# |
C++ |
Web Developer |
|---|---|---|---|---|
Express |
.gif) |
.gif) |
|
|
Standard |
|
|
|
|
Pro et Team |
|
|
|
|
Légende du tableau :
|
Applicable |
|
Non applicable |
.gif) |
Commande ou commandes masquées par défaut. |
L'évaluateur d'expression managée accepte la plupart des expressions écrites en C#. Les rubriques suivantes donnent des informations spécifiques et décrivent certains types d'expressions non pris en charge :
Identificateurs et types
Évaluation de méthode
Opérateurs
Opérateurs surchargés
Chaînes
Casts
Opérateurs typeof et sizeof
Évaluation de propriété
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.
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 Comment : définir un point d'arrêt sur fonction.
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 :
Les opérateurs relationnels et d'égalité : (expr1 > expr2, expr1 < expr2, expr1 <= expr2, expr1 => expr2, expr1 == expr2, expr1 != expr2).
Les opérateurs booléens : (expr1 && expr2, expr1 || expr2, expr1 ? expr2 : expr3).
Les opérateurs arithmétiques : (expr1 + expr2,expr1 - expr2, expr1 * expr2, expr1 / expr2, expr1 % expr2 ).
Les opérateurs logiques : (expr1 & expr2, expr1 ^ expr2, expr1 | expr2).
Les opérateurs de décalage : (expr1 >> expr2, expr1 << expr2).
Les opérateurs d'assignation : (lvalue = expr2, lvalue *= expr2lvalue /= expr2, lvalue %= expr2, lvalue += expr2, lvalue -= expr2, lvalue <<= expr2, lvalue >>= expr2, lvalue &= expr2, lvalue ^= expr2, lvalue |= expr2).
Les 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
expr1expr2
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 :
objet1 <<objet2
objet1 >> objet2
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]
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"
Casts
Les expressions de cast simples fonctionnent dans le débogueur :
(A)x
Les casts qui utilisent des pointeurs ne fonctionnent pas dans le débogueur.
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.
É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.
WebMethods
Vous ne pouvez pas appeler de WebMethods à partir des fenêtres du débogueur.