Como você usa a janela imediata no Visual Studio?

A Janela Imediata é uma ferramenta imensamente útil para depurar aplicativos. Ele pode ser usado para executar instruções de código válidas no contexto de um ponto de interrupção e inspecionar valores. Também o uso para digitar trechos de código para aprender os recursos do idioma.

Como você usa a janela imediata?

Um recurso interessante da janela imediata no Visual Studio é a sua capacidade para avaliar o valor de retorno de um método particularmente se for chamado pelo seu código de cliente, mas é não parte de uma atribuição de variável. No modo Debug, como mencionado, você pode interagir com variáveis ​​e executar expressões na memória, que desempenham um papel importante na capacidade de fazer isso.

Por exemplo, se você tivesse um método estático que retorne a soma de dois números, como:

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

Em seguida, na janela imediata, você pode digitar o seguinte:

? GetSum(2, 4)
6

Como você pode ver, isso funciona muito bem para métodos estáticos. No entanto, se o método não for estático, você precisará interagir com uma referência ao objeto ao qual o método pertence.

Por exemplo, digamos que é assim que sua classe se parece:

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

Se o objeto já existir na memória e estiver no escopo, você poderá chamá-lo na Janela Imediata desde que instanciado antes do seu ponto de interrupção atual (ou, pelo menos, antes de onde o código estiver pausado no modo de depuração):

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

Além disso, se você deseja interagir e testar o método diretamente, sem depender de uma instância existente na memória, instancia sua própria instância na Janela Imediata:

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

Você pode dar um passo adiante e atribuir temporariamente os resultados do método a variáveis, se desejar fazer mais avaliações, cálculos, etc .:

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

Além disso, se você nem deseja declarar um nome de variável para um novo objeto e apenas deseja executar um de seus métodos / funções, faça o seguinte:

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

Uma maneira muito comum de ver o valor de um método é selecionar o nome do método de uma classe e fazer um 'Add Watch' para que você possa ver seu valor atual na janela Watch. No entanto, mais uma vez, o objeto precisa ser instanciado e dentro do escopo para que um valor válido seja exibido. Isso é muito menos poderoso e mais restritivo do que usar a Janela Imediata.

Junto com os métodos de inspeção, você pode fazer equações matemáticas simples:

? 5 * 6
30

ou compare valores:

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

O ponto de interrogação ('?') É desnecessário se você estiver diretamente na Janela Imediata, mas está incluído aqui para maior clareza (para distinguir entre expressões digitadas versus resultados). No entanto, se você estiver na Janela de Comando e precisar para fazer algumas coisas rápidas na Janela Imediata, preceda suas declarações com '?' e lá vai você.

O Intellisense trabalha na Janela Imediata , mas às vezes pode ser um pouco inconsistente. Na minha experiência, parece estar disponível apenas no modo Debug, mas não no design, no modo não-debug.

Infelizmente, outra desvantagem da janela imediata é que ela não suporta loops.

Use a janela imediata para executar comandos

A janela imediata também pode ser usada para executar comandos. Basta digitar a >seguido do comando.

Por exemplo >shell cmd, iniciará um shell de comando (isso pode ser útil para verificar quais variáveis ​​de ambiente foram passadas para o Visual Studio, por exemplo). >clslimpará a tela.

Aqui está uma lista de comandos que são tão comumente usados ​​que têm seus próprios aliases: https://msdn.microsoft.com/en-us/library/c3a0kd3x.aspx

A janela Imediata é usada para depurar e avaliar expressões, executar instruções, imprimir valores de variáveis ​​e assim por diante. Permite inserir expressões a serem avaliadas ou executadas pela linguagem de desenvolvimento durante a depuração.

Para exibir a janela imediata, escolha Depurar> Windows> imediata ou pressione Ctrl-Alt-I

Aqui está um exemplo com a janela imediata:

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

adicionar ponto de interrupção

comandos de chamada

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