Expressões em C# e F#
O avaliador de expressão gerenciado aceita a maioria das expressões gravadas em C#.
No entanto, o avaliador de expressão gerenciado não reconhece expressões em F#. Se você estiver depurando em F#, precisará converter as expressões na sintaxe C# antes de inserir expressões em uma janela do depurador ou em uma caixa de diálogo. Quando você converter expressões de F# em C#, certifique-se de que C# usa o operador == para testar a igualdade, enquanto F# usa o = único.
As seções a seguir oferecem informações específicas e discutem alguns dos tipos de expressão que não têm suporte ou que são parcialmente suportados:
Conversões
Objetos dinâmicos
Identificadores e tipos
Avaliação de método
Operadores
Operadores sobrecarregados
Avaliação de propriedade
Cadeias de caracteres
Operadores typeof e sizeof
WebMethods
O avaliador de expressão ignora public, protected, internal e modificadores de acesso private . Você pode chamar um método private da janela Inspeção, por exemplo. Como o avaliador de expressão ignora modificadores de acesso, é possível que uma carga inesperada seja invocada.
O avaliador de expressão executa todas as avaliações em um contexto implícito não seguro, seja o código que está sendo executado seguro ou não.
O avaliador de expressão também ignora blocos verificados e a opção do compilador /checked. Todas as expressões estão avaliadas em um contexto desmarcado.
Você pode personalizar a exibição de tipos de dados personalizados usando atributos. Para obter mais informações, consulte Exibir tipos de dados personalizados.
Conversões
Trabalho de expressões de conversão simples no depurador:
(A)x
Conversões que envolvem ponteiros não funcionam no depurador.
Objetos dinâmicos
O avaliador de expressão pode avaliar as variáveis estaticamente tipadas como dinâmicas. Também pode avaliar os objetos que implementam a interface IDynamicObject. Quando os objetos que implementam a interface IDynamicObject são avaliados na janela Inspeção, um nó do Modo de Exibição Dinâmico é adicionado. O nó do Modo de Exibição Dinâmico exibe membros do objeto, mas não permite editar os valores dos membros.
Os seguintes recursos de objetos dinâmicos não têm suporte:
Os operadores compostos +=, -=, %=, /=, e *=
Várias conversões, inclusive conversões numéricas e conversões de tipo de argumento
Chamadas de método com mais de dois argumentos
Getters da propriedade com mais de dois argumentos
Setters de propriedade com argumentos
Atribuição a um indexador
Operadores boolianos && e ||
Identificadores e tipos
As expressões do depurador podem usar qualquer identificador visível no escopo atual. Se o depurador for interrompido no método Magh, por exemplo, você poderá usar qualquer identificador visível dentro de Magh, inclusive constantes, nomes de variável e nomes de método.
O depurador pode exibir corretamente qualquer variável de um primitivo, enum ou tipo intrínseco. Para variáveis do tipo de classe, o depurador exibe corretamente o valor com base no tipo mais derivado. Se você tiver um objeto leo do tipo Lion, derivado do tipo Cat, você poderá avaliar leo.Claws e obter o valor correto para um objeto de tipo Lion.
Você pode atribuir um novo valor a qualquer expressão à esquerda que seja um valor l. Isso inclui o primitivo, a classe e os tipos System.Object.
Avaliação de método
O depurador oferece suporte à avaliação de métodos, incluindo métodos sobrecarregados. Em virtude disso, você pode digitar qualquer uma das seguintes expressões e o depurador chamará a versão correta dos métodos sobrecarregados:
Time.Set();
Time.Set(atime);
Avaliar um método no depurador realmente chama e executa o código do método. Se o método tiver efeitos colaterais, avaliar o método em uma janela do depurador modificará o estado do programa, que pode produzir resultados inesperados.
Quando você define um ponto de interrupção em um método sobrecarregado, o local do ponto de interrupção depende de como você especifica o método. Se você especificar a assinatura completa (nome do método e lista de argumentos completa), o depurador definirá um ponto de interrupção na sobrecarga especificada. Se você especificar apenas o nome do método, o comportamento do depurador dependerá da definição de opções do Visual Studio. Se a caixa de seleção Usar o IntelliSense para verificar o nome da função não for selecionada, o depurador definirá um ponto de interrupção em cada sobrecarga daquele nome do método. Caso contrário a caixa de diálogo Escolher ponto de interrupção abrirá, permitindo que você especifique em quais sobrecargas colocar o ponto de interrupção. Para obter mais informações, consulte Pontos de interrupção: usar contagens de ocorrências, funções da pilha de chamadas e condições para interromper quando e onde você quiser no Depurador do Microsoft Visual Studio.
A criação de novos métodos anônimos não tem suporte no depurador nesta versão do Visual Studio.
Operadores
O depurador avalia corretamente a maioria dos operadores internos, incluindo:
Operadores de igualdade e relacional: ( expr1> expr2, expr1< expr2, expr1<= expr2, expr1=> expr2, expr1== expr2, expr1!= expr2).
Operadores boolianos: (expr1&& expr2, expr1|| expr2, expr1? expr2: expr3).
Operadores aritméticos: (expr1+ expr2,expr1- expr2, expr1* expr2, expr1/ expr2, expr1% expr2 ).
Operadores lógicos: (expr1& expr2, expr1^ expr2, expr1).| expr2 ).
Operadores shift: (expr1>> expr2, expr1<< expr2 ).
Operadores de atribuição: ( lvalue= expr2,lvalue*= expr2,lvalue/= expr2, lvalue%= expr2, lvalue+= expr2, lvalue-= expr2, lvalue<<= expr2, lvalue>>= expr2, lvalue&= expr2, lvalue^= expr2, lvalue|= expr2).
Operadores unários: ( +expr1, - expr1, expr1++, ++expr1, expr1--, --expr1).
Operadores sobrecarregados
A maioria dos operadores sobrecarregados trabalham no depurador.
Operadores infixos sobrecarregados +, -, /, %, e & funcionam:
expr1 + expr2
expr1 - expr2
expr1 / expr2
expr1 % expr2
expr1 & expr2
Operadores infixos sobrecarregados =, &&, &, e ||, não funcionam:
expr1 = expr2
expr1 && expr2
expr1 & expr2
expr1 || expr2
Os operadores infixos sobrecarregados << e >> não funcionarão se ambos os operandos forem variáveis da classe:
object1 <<object2
object1 >> object2
Operadores pré-fixos sobrecarregados +, -, ++, --, !, e ~ funcionam:
+ expr1
- expr1
++ expr1
-- expr1
! expr1
~ expr1
Operadores sufixos sobrecarregados ++ e -- funcionam:
expr1 ++
expr1 --
Indexadores sobrecarregados funcionam:
- expr1 [ expr2 ]
Avaliação de propriedade
O depurador pode avaliar propriedades em qualquer janela variável. No entanto, avaliar uma propriedade no depurador pode ter efeitos colaterais que geram resultados inesperados e indesejados. Para proteger contra efeitos colaterais causados pela avaliação acidental, você pode desativar a avaliação da propriedade da caixa de diálogo Opções.
Cadeias de caracteres
O depurador reconhece o operador indexado quando é usado com cadeias de caracteres bem como matrizes. Por exemplo, você pode inserir:
"hello world"[0]
A janela Inspeção exibirá o valor correto:
'h'
Em C#, ao contrário do C/C++ nativo, você pode editar o valor de uma cadeia de caracteres no depurador. Além disso, você pode usar o operador Length em uma cadeia de caracteres:
mystring.Length
-ou-
"hello world".Length
Em C#, você pode concatenar cadeias de caracteres:
"hello" + "world"
Operadores typeof e sizeof
O depurador oferece suporte aos operadores typeof e sizeof transformando-os nas funções .NET Framework equivalentes.
typeof ( expression )
é transformado em:
System.Type.GetType( expression )
O depurador avalia essa expressão transformada.
O depurador oferece suporte ao operador sizeof.
WebMethods
Você não pode chamar WebMethods das janelas do depurador.