Posso descobrir o valor de retorno antes de retornar durante a depuração no Visual Studio?

Execute a seguinte função:

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

Quando defino um ponto de interrupção nesta função, existe a possibilidade de inspecionar o valor retornado? go()está diretamente acoplado a um datagrid em uma .aspxpágina.

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

Não que eu saiba. Note que se você fazer adicionar uma variável, ele será removido pelo compilador em compilações de qualquer maneira ...

Atualização: essa funcionalidade foi adicionada ao VS2013 . Você pode ver os valores de retorno nas janelas de automóveis ou usá-los na janela de inspeção $ReturnValue/ imediata.

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

Atualização para o VS2015: boo! infelizmente, não parece estar na atualização do VS2015 (devenv v14)
para o VS2017: está de volta. (devenv v15)

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

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

Concordo que isso é uma coisa muito útil: não apenas ver o valor de retorno do método antes de sair dele, mas também ver o valor de retorno dos métodos 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:

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

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

Para aqueles que têm experiência em depurar códigos nativos C ++ ou VB6, você pode ter usado um recurso em que os valores de retorno de função são fornecidos na janela Autos. Infelizmente, essa funcionalidade não existe para o código gerenciado. Embora você possa solucionar esse problema atribuindo os valores de retorno a uma variável local, isso não é tão conveniente porque requer a modificação do seu código. No código gerenciado, é muito mais difícil determinar qual o valor de retorno de uma função que você passou por cima. Percebemos que não era possível fazer a coisa certa de forma consistente aqui e, portanto, removemos o recurso em vez de fornecer resultados incorretos no depurador. No entanto, queremos trazer isso de volta para você e nossas equipes de CLR e Depurador estão procurando várias soluções possíveis 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

Em relação ao Visual Studio 2015:

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 automóveis ou usar $ ReturnValue na janela de inspeção / imediata

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

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

Eu testei isso no Visual Studio 2015 Enterprise:

• Com os avaliadores de expressão herdados desativados: apenas $ ReturnValue1 funciona
• Com legados avaliadores de expressão ligado: ambos $ ReturnValue e $ ReturnValue1 trabalho

Se você for ao menu Ferramentas → Opções , IntelliTrace e alterar a configuração para coletar eventos e informações de chamada.

Você pode voltar ao evento de chamada anterior ( Ctrl+ Shift+ F11) e ver o valor temporário retornado da chamada de método na janela de automóveis 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á. Apenas mostra o valor de retorno do último método chamado no método atual.

Então, tudo bem para

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

pois 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 Registros e veja o valor do registro EAX. Contém o valor de retorno da última função chamada.

Saia do método go () usando Shift-F11 e, na janela de depuração "Autos", ele mostrará o valor de retorno da chamada do 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 agradável. Uma desvantagem significativa é que você teria que esperar 5, talvez 6 anos. Desde que você postou em novembro de 2008, sugiro que você waaaaaa ...

... aaaait. E voilà! Somente para você, a MS lançou o Visual Studio 2013 mais recente, onde é um recurso padrão acessível a partir dos menus enquanto é executado no modo de depuração (menu Debug → Windows → Autos ).

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

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

Ainda me parece inconveniente - especialmente se você não souber qual valor de retorno precisará antes de iniciar a depuração. Eu realmente não quero ter uma variável temporária bagunçando meu código toda vez que eu retornar algo.

Em teoria, o depurador pode ter uma returnvariável. Afinal: é 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.

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

Se você aninhava chamadas de função, as pseudo-variáveis $ResultValueXsão criadas automaticamente, onde X se refere à ordem de chamada da função. Portanto, se você tiver uma chamada como Multiply(Five(), Six()), as seguintes pseudo-variáveis ​​serão criadas:

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

O Microsoft Visual C ++ costumava fazer isso, mas o Visual Studio não faz o AFAIK .. :(

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

someTableAdapter.getSomeData();

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

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

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

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

Sim, mudando para o VB.NET. ; P (Você acabou de dizer "Visual Studio".;)

Desde que me lembro (do Visual Basic a todas as versões do VB.NET), você pode simplesmente consultar o nome da função. Ele "funciona" como uma variável local declarada implicitamente no início da função e seu valor atual também é usado como valor de retorno sempre que a função sai por meio de instruções de não retorno ( Exit Functionou seja, apenas está caindo) e, é claro, quando a declaração de retorno é usada.

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

Esse pequeno recurso do VB.NET (mais a Exit Functioninstrução que ele habilita - outro recurso que o C # não tem e deve) é muito útil em uma forma de programação defensiva que eu pratico onde sempre inicializo o nome da função para o valor de falha / padrão como o primeira declaração. Então, em qualquer ponto de falha (que normalmente ocorre com muito mais frequência do que pontos de sucesso), posso simplesmente chamar a Exit Functiondeclaração (ou seja, sem ter que duplicar a expressão de falha / padrão ou mesmo um nome de constante / variável).

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

Você pode tentar selecionar "someTableAdapter.getSomeData();", clicar com o botão direito do mouse e ir para o Quick Watch .

Arraste e solte a expressão de retorno em uma janela de inspeçã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 para qualquer expressão.