Fonctionnalités communes de l'évaluateur d'expression

Article
06/10/2015

Cette rubrique décrit diverses fonctionnalités de l'évaluateur d'expression communes au débogueur et ne variant que selon le langage.

Variables implicites

En Visual Basic et C#, vous pouvez créer des variables implicites à l'aide de l'évaluateur d'expression. Ces variables implicites ne sont jamais hors de portée et peuvent être traitées comme toute autre variable.

En C#, vous pouvez créer une variable implicite en la déclarant dans l'évaluateur d'expression. Par exemple, vous pouvez entrer le code C# suivant dans la fenêtre Exécution :

int b = 100;

Lorsque vous exécutez ce code dans la fenêtre Exécution, la nouvelle variable implicite apparaît dans la fenêtre Variables locales et le signe $ précède le nom de la variable, dans ce cas, $b.

En Visual Basic, vous ne pouvez pas créer de variables implicites dans l'évaluateur d'expression. En revanche, si vous utilisez une variable non déclarée dans l'évaluateur d'expression Visual Basic, une variable implicite est automatiquement créée. En Visual Basic, les variables implicites ne sont pas répertoriées dans la fenêtre Variables locales.

Points d'arrêt

Si vous utilisez la fenêtre Exécution pour évaluer une méthode ou une fonction Visual Basic ou C# qui contient un point d'arrêt, ce point d'arrêt est atteint et un nouveau frame apparaît sur la pile des appels. Voici un exemple en C# :

    class Program
    {
        static void Main(string[] args)
        {
// Breakpoint here:
             int a = 20;
         }
    }

Si vous définissez un point d'arrêt à l'endroit où le commentaire l'indique, puis compilez et exécutez le programme en appuyant sur F5, vous atteignez le point d'arrêt normalement. Puis, si vous évaluez la méthode Main en tapant Program.Main(null) dans la fenêtre Exécution, le point d'arrêt est atteint une seconde fois et il y a une entrée pour la méthode sur la pile des appels.

Évaluation dans la fenêtre Espion

Pour éviter les possibles effets secondaires indésirables, un appel à une fonction ou à une méthode n'est pas évalué automatiquement à chacune des étapes du débogueur. À la place, une icône vous permet de mettre à jour le résultat manuellement. Le résultat apparaît dans la colonne Valeur. Cela vous permet d'évaluer l'appel manuellement. Pour plus d'informations, consultez Effets secondaires et expressions.

Identité de l'objet

Cette fonctionnalité n'est pas disponible pour Visual Basic.

Certaines applications créent de nombreuses instances d'une classe. Dans ce cas, il est souvent utile d'avoir un identificateur pour distinguer une instance donnée de la classe. Par exemple, cela peut s'avérer utile si une instance spécifique de la classe ne se comporte pas de la manière attendue ou si une instance spécifique a été insérée plusieurs fois dans une collection qui doit ne la contenir qu'une fois.

Identité d'un objet natif

Lorsque vous déboguez du code non managé, vous pouvez identifier un objet de manière unique à l'aide de son adresse. C'est important pour deux raisons :

Vous pouvez suivre un objet en utilisant seulement son adresse. Vous pouvez utiliser une adresse pour :
- afficher la valeur de l'objet à cette adresse ;
- Vérifier l'égalité. L'adresse d'un objet peut fréquemment être utilisée de la même façon que la variable de l'objet proprement dite.
Vous pouvez utiliser l'adresse d'un objet, l'instance, pour définir un point d'arrêt sur une méthode dans cette instance spécifique.

Par exemple, supposez qu'un objet est une instance de la classe CMyType, dont l'adresse est 0xcccccccc. Vous pouvez spécifier un point d'arrêt sur fonction sur la méthode aMethod de cette instance comme suit :

((CMyType *) 0xcccccccc)->aMethod

Identité d'un objet managé

Avec du code managé, vous ne pouvez pas utiliser l'adresse de l'objet pour identifier ce dernier. À la place, vous utilisez un entier connu en tant qu'ID d'objet généré par les services de débogage du Common Language Runtime (CLR) et associé à l'objet. Ce nombre est un entier positif généré par les services de débogage du CLR. La valeur de l'ID objet n'a comme intérêt que celui d'identifier l'objet de manière unique.

Les handles d'objet sont affichés comme entiers de longueur variable, décimaux, suivis du signe dièse (#), sans zéros non significatifs, par exemple 5#. Les handles apparaissent dans la colonne Valeur dans différentes fenêtres de données du débogueur.

Pour créer un ID d'objet pour une variable, cliquez avec le bouton droit sur cette dernière, puis sélectionnez Générer ID de l'objet. Le débogueur affiche un nombre suivi du signe dièse (#), tel que 123#. Pour supprimer l'ID d'un objet, cliquez avec le bouton droit sur la variable et sélectionnez Supprimer l'ID de l'objet.

Lorsqu'un point d'arrêt est atteint, vous pouvez taper le handle d'une variable dans la fenêtre Espion. Le débogueur affiche la valeur de l'ID d'objet, que vous pouvez développer et inspecter comme toute autre variable.

Vous pouvez utiliser l'ID d'objet pour définir un point d'arrêt sur la méthode d'une instance spécifique. Par exemple, supposez que vous avez un objet correspondant à une instance de classe CMyType dont l'ID est 5#. La classe CMyType inclut une méthode aMethod. Vous pouvez définir un point d'arrêt sur fonction sur la méthode aMethod de l'instance de 5# comme suit :

((CMyType) 5#).aMethod

Vous pouvez également utiliser l'ID d'objet dans une condition de point d'arrêt. L'exemple suivant vous explique comment tester l'ID d'objet dans une condition.

this == 5#