Posso descobrir o valor de retorno antes de retornar durante a debugging no Visual Studio?

Tome a seguinte function:

DataTable go() { return someTableAdapter.getSomeData(); } 

Quando eu defino um ponto de interrupção nessa function, existe a possibilidade de inspecionar o valor retornado? go() é diretamente acoplado a um datagrid em uma página .aspx .

A única maneira de inspecionar a tabela de dados retornada é usar uma variável temporária. No entanto, isso é um pouco inconveniente. Não há outro caminho?

Não que eu saiba. Note que se você adicionar uma variável, ela será removida pelo compilador em versões de lançamento …

Atualização: essa funcionalidade foi adicionada ao VS2013 . Você pode ver os valores de retorno nas janelas de autos ou usar $ReturnValue na janela watch / immediate.

O valor só pode ser visto diretamente após retornar da function, portanto, a maneira mais fácil de acessá-lo é colocar um ponto de interrupção na chamada de function e passar (F10) a chamada.


Atualização para VS2015: boo! infelizmente, não parece estar em VS2015 (devenv v14)

Isso pode ser feito no Visual Studio 2013 com o CLR 4.5.1, de acordo com o site de comentários do cliente . Não estava disponível em versões anteriores para o C #.

(O Visual Studio 2008 e versões anteriores suportavam-no para o VB.NET. Ele sempre esteve disponível para desenvolvedores de C / C ++.)

Eu concordo que isso é uma coisa muito útil de se ter: não apenas ver o valor de retorno do método antes de sair dele, mas também ver o valor de retorno dos methods que acabei de passar. Eu o implementei como parte de uma extensão comercial para o Visual Studio chamada ” OzCode “.

Com ele, você pode visualizar os valores de retorno do método diretamente no editor de código, como uma espécie de exibição do HUD:

Visualização de instrução

Para mais informações, veja este vídeo .

Segundo a Microsoft, não há como implementar isso de forma confiável com código gerenciado. Este é um problema que eles conhecem e estão trabalhando:

Para aqueles que têm experiência com debugging de código C ++ ou VB6 nativo, você pode ter usado um recurso no qual os valores de retorno da function são fornecidos para você na janela do Autos. Infelizmente, essa funcionalidade não existe para código gerenciado. Enquanto você pode contornar esse problema, atribuindo os valores de retorno a uma variável local, isso não é tão conveniente porque requer a modificação de seu código. No código gerenciado, é muito mais difícil determinar qual o valor de retorno de uma function que você percorreu. Percebemos que não poderíamos fazer a coisa certa de forma consistente aqui e, por isso, removemos o recurso em vez de fornecer resultados incorretos no depurador. No entanto, queremos trazer isso de volta para você e nossas equipes CLR e Debugger estão analisando um número de possíveis soluções para esse problema. Infelizmente isso não fará parte do Visual Studio 11.

https://connect.microsoft.com/VisualStudio/feedback/details/597933/add-a-return-pseudo-variable-to-the-visual-studio-debugger-for-net-code

De acordo com a resposta atualmente aceita por Marc Gravell:

Essa funcionalidade foi adicionada ao Visual Studio 2013 . Você pode ver os valores de retorno nas janelas de autos ou usar $ ReturnValue na janela watch / immediate

Essa resposta também afirmou que essa funcionalidade não funciona no Visual Studio 2015. Isso não é (inteiramente) verdadeiro. Em Examine valores de retorno de chamadas de método, há a seguinte nota:

Você deve ter os avaliadores legados de expressões ativados para que o $ ReturnValue seja reconhecido (Ferramentas / Opções / Depuração / Usar os avaliadores legados de expressões C # e VB ). Caso contrário, você pode usar $ ReturnValue1 .

Eu testei isso no Visual Studio 2015 Enterprise:

  • Com os avaliadores legados de expressões desativados: somente $ ReturnValue1 funciona
  • Com os avaliadores legados de expressões ativados: os methods $ ReturnValue e $ ReturnValue1

Se você acessar o menu FerramentasOpções , o IntelliTrace e alterar a configuração para coletar events e chamar informações.

Você pode voltar ao evento de chamada anterior ( Ctrl + Shift + F11 ) e ver o valor temporário retornado da chamada do método na janela de autos como um filho do nome do método.

Isso não está mostrando o valor de retorno para o método em que você está. Ele apenas mostra o valor de retorno do último método chamado no método atual.

Então, tudo bem por

 DataTable go(){return someTableAdapter.getSomeData();} 

como mostra o valor de retorno para someTableAdapter.getSomeData() .

Mas não para:

 int go(){return 100 * 99;} 

Truque antigo dos dias anteriores ao .NET: Abra a janela Registers e observe o valor do registrador EAX. Contém o valor de retorno da última function chamada.

Saia do método go () usando Shift-F11 e, em seguida, na janela de debugging “Autos”, ele mostrará o valor de retorno da chamada de método que acabou de sair da pilha (nesse caso, o método go () que é o que você quer). Esse é o comportamento no Visual Studio 2005; Eu não usei o Visual Studio 2008, então não sei se isso se comporta da mesma maneira nessa versão.

Sim, existe uma maneira muito legal. Uma desvantagem significativa é que você teria que esperar 5, talvez 6 anos. Desde que eu vejo que você postou em novembro de 2008, sugiro que você waaaaaa …

… aaaait. E voilà! Só para você, a MS lançou o mais recente Visual Studio 2013, onde é um recurso padrão acessível a partir dos menus durante a execução no modo de debugging (menu DebugWindowsAutos ).

Há muitas soluções alternativas, mas nenhuma parece satisfatória.

Para citar John Skeet abaixo (comente sobre uma resposta agora excluída):

Ainda parece inconveniente para mim – especialmente se você não sabe qual valor de retorno vai precisar antes de iniciar a debugging. Eu realmente não quero ter uma variável temporária bagunçando meu código toda vez que eu devolver algo.

Em teoria, o depurador poderia ter uma variável de return . Afinal de contas: é apenas uma variável na pilha:

 unsafe { int * sp = stackalloc int[1]; try { return a+b; } finally { Trace.WriteLine("return is " + *(sp+3)); } } 

Portanto, considere isso uma solicitação de recurso para o Visual Studio.

Microsoft Visual C ++ costumava fazer isso, mas o Visual Studio não AFAIK .. 🙁

A única maneira que conheço é colocar um ponto de interrupção na linha de retorno e, em seguida, chamar a janela Quick Watch e inserir a expressão retornada:

 someTableAdapter.getSomeData(); 

Mas isso só funciona se a chamada não alterar o estado de qualquer object (já que haverá uma segunda chamada para o mesmo método quando você retomar a execução).

Eu queria expandir a resposta de PascalK para fazer isso funcionar no Visual Studio 2015, porque há um recurso oculto que não está documentado em Examine valores de retorno de chamadas de método .

Se você tiver chamadas de function aninhadas, as pseudo-variables $ResultValueX são criadas automaticamente, onde o X se refere à ordem de chamada da function. Portanto, se você tiver uma chamada como Multiply(Five(), Six()) , as seguintes pseudo-variables ​​serão criadas:

 Five() | $ResultValue1 = 5 Six() | $ResultValue2 = 6 Multiply() | $ResultValue3 = 30 

Você também pode pedir para avaliar o valor na janela intermediária também, se ele não definir sinalizadores ou outras variables, mas apenas retornar algo.

Eu acho que você pode determinar isso, olhando para o registrador RAX na janela Registers (Debug / Windows / Registers). Após sair (SHIFT + F11) da function, verifique o registro RAX. Eu não sei de fato, mas uma vez em uma lua você poderia verificar um registrador (pré dias de .NET) e ver o valor de retorno lá. Pode até ser uma combinação de RAX e RBX, etc.

Abrir a janela Depurar → Autos aproxima-o. Ele não mostrará o valor de retorno real, mas mostrará o que foi avaliado na declaração de retorno.

Sim, mudando para VB.NET. P (Você acabou de dizer “Visual Studio”.)

Por quanto tempo eu me lembro (do Visual Basic através de todas as versões do VB.NET), você pode simplesmente consultar o nome da function. Ele “funciona” como uma variável local que é implicitamente declarada no início da function e seu valor atual também é usado como o valor de retorno sempre que a function sai via meios de declaração de não retorno (ex. , quando a declaração de retorno é usada.

Ele também é configurado para a expressão da declaração de retorno. Assim como uma variável local, seu valor pode ser inspecionado em qualquer ponto de execução dentro da function (incluindo após a instrução de retorno ser executada). C # não tem isso e deveria.

Esse pequeno recurso do VB.NET (mais a instrução Exit Function que ele habilita – outro recurso que C # não tem e deveria) é muito útil em uma forma de programação defensiva que pratico onde sempre inicializo o nome da function para o valor padrão / falha como a primeira declaração. Então, em qualquer ponto de falha (que normalmente ocorre muito mais frequentemente do que pontos de sucesso), eu posso simplesmente chamar a instrução Exit Function (isto é, sem ter que duplicar a expressão falha / default ou mesmo um nome constante / variável).

A resposta aceita não funciona corretamente com o Visual Studio 2015, mas colocando um ponto de interrupção na última linha do método e pressionando F10 , ele colocará todas as expressões do valor de retorno na janela de locais.

Você pode tentar selecionar "someTableAdapter.getSomeData();" , clique com o botão direito e vá para o Quick Watch .

Arraste e solte a expressão de retorno em uma janela de exibição.

Por exemplo, na declaração

 return someTableAdapter.getSomeData(); 

arraste e solte

 someTableAdapter.getSomeData() 

em uma janela de inspeção e você verá o valor.

Você pode fazer isso por qualquer expressão.