Comment utilisez-vous la fenêtre exécution dans Visual Studio?

La fenêtre immédiate est un outil extrêmement utile pour le débogage des applications. Il peut être utilisé pour exécuter des instructions de code valides dans le contexte d'un point d'arrêt et inspecter des valeurs. Je l'utilise également pour taper des extraits de code afin d'apprendre les fonctionnalités linguistiques.

Comment utilisez-vous la fenêtre d'exécution?

Une fonctionnalité intéressante de la fenêtre immédiate dans Visual Studio est sa capacité à évaluer la valeur de retour d'une méthode, en particulier si elle est appelée par votre code client mais qu'elle ne fait pas partie d'une affectation de variable. En mode Débogage, comme mentionné, vous pouvez interagir avec des variables et exécuter des expressions en mémoire, ce qui joue un rôle important pour pouvoir le faire.

Par exemple, si vous aviez une méthode statique qui renvoie la somme de deux nombres tels que:

private static int GetSum(int a, int b)
{
    return a + b;
}

Ensuite, dans la fenêtre d'exécution, vous pouvez taper ce qui suit:

? GetSum(2, 4)
6

Comme vous pouvez le voir, cela fonctionne très bien pour les méthodes statiques. Cependant, si la méthode n'est pas statique, vous devez interagir avec une référence à l'objet auquel appartient la méthode.

Par exemple, disons que voici à quoi ressemble votre classe:

private class Foo
{
    public string GetMessage()
    {
        return "hello";
    }
}

Si l'objet existe déjà en mémoire et qu'il est dans la portée, vous pouvez l'appeler dans la fenêtre d'exécution tant qu'il a été instancié avant votre point d'arrêt actuel (ou, au moins, avant que le code soit mis en pause en mode débogage):

? foo.GetMessage(); // object ‘foo’ already exists
"hello"

De plus, si vous souhaitez interagir et tester la méthode directement sans vous fier à une instance existante en mémoire, vous pouvez instancier votre propre instance dans la fenêtre d'exécution:

? Foo foo = new Foo(); // new instance of ‘Foo’
{temp.Program.Foo}
? foo.GetMessage()
"hello"

Vous pouvez aller plus loin et affecter temporairement les résultats de la méthode à des variables si vous souhaitez effectuer d'autres évaluations, calculs, etc.:

? string msg = foo.GetMessage();
"hello"
? msg + " there!"
"hello there!"

De plus, si vous ne souhaitez même pas déclarer un nom de variable pour un nouvel objet et que vous souhaitez simplement exécuter l'une de ses méthodes / fonctions, procédez comme suit:

? new Foo().GetMessage()
"hello" 

Une manière très courante de voir la valeur d'une méthode est de sélectionner le nom de la méthode d'une classe et de faire un 'Add Watch' afin que vous puissiez voir sa valeur actuelle dans la fenêtre Watch. Cependant, une fois encore, l'objet doit être instancié et dans la portée d'une valeur valide à afficher. C'est beaucoup moins puissant et plus restrictif que l'utilisation de la fenêtre immédiate.

En plus des méthodes d'inspection, vous pouvez faire des équations mathématiques simples:

? 5 * 6
30

ou comparer des valeurs:

? 5==6
false
? 6==6
true

Le point d'interrogation ('?') N'est pas nécessaire si vous êtes directement dans la fenêtre d'exécution, mais il est inclus ici pour plus de clarté (pour faire la distinction entre les expressions saisies et les résultats.) Cependant, si vous êtes dans la fenêtre de commande et que vous avez besoin pour faire des trucs rapides dans la fenêtre Exécution puis faites précéder vos déclarations avec '?' et c'est parti.

Intellisense fonctionne dans la fenêtre d'exécution , mais il peut parfois être un peu incohérent. D'après mon expérience, il semble être uniquement disponible en mode débogage, mais pas en mode conception, sans débogage.

Malheureusement, un autre inconvénient de la fenêtre d'exécution est qu'elle ne prend pas en charge les boucles.

Utilisez la fenêtre Exécution pour exécuter des commandes

La fenêtre Exécution peut également être utilisée pour exécuter des commandes. Tapez simplement un >suivi de la commande.

Par exemple >shell cmd, démarrera un shell de commande (cela peut être utile pour vérifier quelles variables d'environnement ont été transmises à Visual Studio, par exemple). >clseffacera l'écran.

Voici une liste de commandes qui sont si couramment utilisées qu'elles ont leurs propres alias: https://msdn.microsoft.com/en-us/library/c3a0kd3x.aspx

La fenêtre Exécution est utilisée pour déboguer et évaluer des expressions, exécuter des instructions, imprimer des valeurs de variables, etc. Il vous permet de saisir des expressions à évaluer ou à exécuter par le langage de développement lors du débogage.

Pour afficher la fenêtre Exécution, choisissez Déboguer> Windows> Immédiat ou appuyez sur Ctrl-Alt-I

Voici un exemple avec la fenêtre immédiate:

int Sum(int x, int y) { return (x + y);}
void main(){
int a, b, c;
a = 5;
b = 7;
c = Sum(a, b);
char temp = getchar();}

ajouter un point d'arrêt

commandes d'appel

https://msdn.microsoft.com/en-us/library/f177hahy.aspx