Come si utilizza la finestra immediata in Visual Studio?

La finestra immediata è uno strumento estremamente utile per il debug delle applicazioni. Può essere utilizzato per eseguire istruzioni di codice valide nel contesto di un punto di interruzione e controllare i valori. Lo uso anche per digitare frammenti di codice per apprendere le funzionalità del linguaggio.

Come si utilizza la finestra immediata?

Una caratteristica della finestra immediata in Visual Studio è la sua capacità di valutare il valore di ritorno di un metodo particolarmente se viene chiamato dal codice cliente, ma è non è parte di un assegnamento di variabile. In modalità Debug, come detto, è possibile interagire con variabili ed eseguire espressioni in memoria che giocano un ruolo importante nel poterlo fare.

Ad esempio, se avessi un metodo statico che restituisce la somma di due numeri come:

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

Quindi nella finestra immediata puoi digitare quanto segue:

? GetSum(2, 4)
6

Come puoi vedere, funziona molto bene per i metodi statici. Tuttavia, se il metodo non è statico, è necessario interagire con un riferimento all'oggetto a cui appartiene il metodo.

Ad esempio, supponiamo che questo sia l'aspetto della tua classe:

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

Se l'oggetto esiste già in memoria ed è nell'ambito, è possibile chiamarlo nella finestra immediata purché sia ​​stato istanziato prima del punto di interruzione corrente (o, almeno, prima che il codice venga messo in pausa in modalità debug):

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

Inoltre, se si desidera interagire e testare il metodo direttamente senza fare affidamento su un'istanza esistente in memoria, quindi è possibile creare un'istanza vostra propria istanza nella finestra immediata:

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

Puoi fare un ulteriore passo avanti e assegnare temporaneamente i risultati del metodo a variabili se desideri eseguire ulteriori valutazioni, calcoli, ecc .:

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

Inoltre, se non vuoi nemmeno dichiarare un nome di variabile per un nuovo oggetto e vuoi solo eseguire uno dei suoi metodi / funzioni, fallo:

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

Un modo molto comune per vedere il valore di un metodo è selezionare il nome del metodo di una classe ed eseguire un "Add Watch" in modo da poter vedere il suo valore corrente nella finestra Watch. Tuttavia, ancora una volta, l'oggetto deve essere istanziato e nell'ambito per visualizzare un valore valido. Questo è molto meno potente e più restrittivo rispetto all'utilizzo della finestra immediata.

Insieme ai metodi di ispezione, puoi eseguire semplici equazioni matematiche:

? 5 * 6
30

o confronta i valori:

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

Il punto interrogativo ('?') Non è necessario se ci si trova direttamente nella finestra immediata, ma è incluso qui per chiarezza (per distinguere tra le espressioni digitate dai risultati). Tuttavia, se ci si trova nella finestra di comando e si necessita per fare alcune cose veloci nella finestra immediata, quindi far precedere le tue dichiarazioni con "?" e via.

Intellisense funziona nella finestra immediata , ma a volte può essere un po 'incoerente. Nella mia esperienza, sembra essere disponibile solo in modalità di debug, ma non in modalità di progettazione, non di debug.

Sfortunatamente, un altro svantaggio della finestra immediata è che non supporta i cicli.

Utilizzare la finestra immediata per eseguire i comandi

La finestra immediata può essere utilizzata anche per eseguire comandi. Basta digitare un >seguito dal comando.

Ad esempio >shell cmdavvierà una shell dei comandi (questo può essere utile per controllare quali variabili di ambiente sono state passate a Visual Studio, ad esempio). >clscancellerà lo schermo.

Ecco un elenco di comandi che sono così comunemente usati da avere i propri alias: https://msdn.microsoft.com/en-us/library/c3a0kd3x.aspx

La finestra Immediata viene utilizzata per eseguire il debug e valutare espressioni, eseguire istruzioni, stampare valori di variabili e così via. Consente di inserire espressioni che devono essere valutate o eseguite dal linguaggio di sviluppo durante il debug.

Per visualizzare Finestra immediata, scegli Debug> Windows> Immediato o premi Ctrl-Alt-I

Ecco un esempio con Finestra immediata:

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();}

aggiungi punto di interruzione

comandi di chiamata

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