Expresiones en C# y F#
El evaluador de expresiones administradas acepta la mayoría de las expresiones escritas en C#.
Sin embargo, no reconoce las expresiones de F#. Si se está depurando F#, es necesario traducir las expresiones a la sintaxis de C# antes de escribirlas en una ventana o un cuadro de diálogo de depurador. Al traducir expresiones de F# a C#, recuerde que C# utiliza el operador == para comprobar la igualdad, mientras que F# utiliza =.
En las próximas secciones se ofrece información específica y se tratan algunos de los tipos de expresiones que no se admiten o se admiten parcialmente:
Conversiones
Objetos dinámicos
Identificadores y tipos
Evaluación de métodos
Operadores
Operadores sobrecargados
Evaluación de propiedades
Cadenas
Operadores typeof y sizeof
WebMethods
El evaluador de expresiones omite los modificadores de acceso public, protected, internal y private . Por ejemplo, se puede llamar a un método private desde la ventana Inspección. Puesto que el evaluador de expresiones omite los modificadores de acceso, se puede invocar una carga inesperada.
El evaluador de expresiones realiza todas las evaluaciones en un contexto no seguro implícito, independientemente de que el código que se está ejecutando sea seguro o no.
El evaluador de expresiones también omite los bloques comprobados y la opción del compilador /checked. Todas las expresiones se evalúan en un contexto no comprobado.
Es posible personalizar la presentación de tipos de datos personalizados mediante atributos. Para obtener más información, vea Mostrar tipos de datos personalizados.
Conversiones
En el depurador funcionan expresiones de conversión sencillas:
(A)x
Las conversiones que afectan a punteros no funcionan en el depurador.
Objetos dinámicos
El evaluador de expresiones puede evaluar como dinámicas variables con tipos estáticos. También puede evaluar objetos que implementan la interfaz IDynamicObject. Cuando los objetos que implementan la interfaz IDynamicObject se evalúan en la ventana Inspección, se agrega un nodo Vista dinámica. El nodo Vista dinámica muestra los miembros de objetos, pero no permite editar los valores de los miembros.
No se admiten las características siguientes de los objetos dinámicos:
Los operadores compuestos +=, -=, %=, /= y *=
Muchas conversiones, incluidas las conversiones numéricas y las conversiones de argumentos de tipos
Llamadas a métodos con más de dos argumentos
Captadores de propiedades con más de dos argumentos
Establecedores de propiedades con argumentos
Asignación a un indizador
Operadores booleanos && y ||
Identificadores y tipos
Las expresiones del depurador pueden utilizar cualquier identificador visible dentro del ámbito actual. Por ejemplo, si el depurador se detiene en el método Magh, puede utilizar cualquier identificador visible dentro de Magh, incluidas las constantes, los nombres de variable y los nombres de método.
El depurador puede mostrar correctamente cualquier variable de un tipo primitivo, de enumeración o intrínseco. En el caso de variables de tipo clase, el depurador muestra correctamente el valor según el tipo más derivado. Si se tiene un objeto leo de tipo Lion, derivado del tipo Cat, se puede evaluar leo.Claws y obtener el valor correcto de un objeto de tipo Lion.
Se puede asignar un nuevo valor a cualquier expresión del lado izquierdo que sea un valor L. Esto incluye los tipos primitivos, de clase y System.Object.
Evaluación de métodos
El depurador admite la evaluación de métodos, incluidos los métodos sobrecargados. Por tanto, se puede escribir cualquiera de las expresiones siguientes y el depurador llamará a la versión correcta del método sobrecargado:
Time.Set();
Time.Set(atime);
Cuando se evalúa un método en el depurador, en realidad se llama y se ejecuta el código de dicho método. Si el método tiene efectos secundarios, la evaluación del mismo en una ventana de depurador cambiará el estado del programa, lo que puede producir resultados inesperados.
Cuando se establece un punto de interrupción en un método sobrecargado, la ubicación del punto de interrupción depende de cómo se especifique el método. Si se especifica la signatura completa (nombre de método y lista de argumentos completa), el depurador establece un punto de interrupción en la sobrecarga especificada. Si solo se especifica el nombre del método, el comportamiento del depurador depende de una configuración de las opciones de Visual Studio. Si la casilla Usar IntelliSense para comprobar el nombre de la función no está activada, el depurador establecerá un punto de interrupción en cada sobrecarga de ese nombre de método. De lo contrario, se abrirá el cuadro de diálogo Elegir punto de interrupción, donde se pueden especificar las sobrecargas en las que se desea establecer el punto de interrupción. Para obtener más información, vea Puntos de interrupción: Usar números de llamadas, funciones de pila de llamadas y condiciones para realizar interrupciones cuando y donde quiera en el depurador de Visual Studio.
No se admite la creación de nuevos métodos anónimos en el depurador en esta versión de Visual Studio.
Operadores
El depurador evalúa correctamente la mayoría de los operadores integrados, incluidos:
Operadores relacionales y de igualdad: ( expr1> expr2, expr1< expr2, expr1<= expr2, expr1=> expr2, expr1== expr2, expr1!= expr2).
Operadores booleanos: (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 de desplazamiento: (expr1>> expr2, expr1<< expr2 ).
Operadores de asignación: ( lvalue= expr2,lvalue*= expr2,lvalue/= expr2, lvalue%= expr2, lvalue+= expr2, lvalue-= expr2, lvalue<<= expr2, lvalue>>= expr2, lvalue&= expr2, lvalue^= expr2, lvalue|= expr2).
Operadores unarios: ( +expr1, - expr1, expr1++, ++expr1, expr1--, --expr1).
Operadores sobrecargados
La mayoría de los operadores sobrecargados funcionan en el depurador.
Funcionan los operadores de infijo sobrecargados +, -, /, % y &:
expr1 + expr2
expr1 - expr2
expr1 / expr2
expr1 % expr2
expr1 & expr2
Los operadores de infijo sobrecargados =, &&, & y || no funcionan:
expr1 = expr2
expr1 && expr2
expr1 & expr2
expr1 || expr2
Los operadores de infijo sobrecargados << y >> no funcionan si ambos operandos son variables de clase:
object1 <<object2
object1 >> object2
Funcionan los operadores de prefijo sobrecargados +, -, ++, --, ! y ~:
+ expr1
- expr1
++ expr1
-- expr1
! expr1
~ expr1
Funcionan los operadores de sufijo sobrecargados ++ y --:
expr1 ++
expr1 --
Funcionan los indizadores sobrecargados:
- expr1 [ expr2 ]
Evaluación de propiedades
El depurador puede evaluar propiedades en cualquier ventana de variables. Sin embargo, la evaluación de una propiedad en el depurador puede tener efectos secundarios que produzcan resultados inesperados y no deseados. Para protegerse de los efectos secundarios causados por una evaluación accidental, se puede desactivar la evaluación de propiedades en el cuadro de diálogo Opciones.
Cadenas
El depurador reconoce el operador indizado cuando se utiliza con cadenas y con matrices. Por ejemplo, se puede escribir:
"hello world"[0]
La ventana Inspección mostrará el valor correcto:
'h'
En C#, a diferencia de C o C++ nativo, se puede editar el valor de una cadena en el depurador. Además, se puede utilizar el operador Length en una cadena:
mystring.Length
O bien
"hello world".Length
En C#, se pueden concatenar cadenas:
"hello" + "world"
Operadores typeof y sizeof
El depurador admite los operadores typeof y sizeof al transformarlos en las funciones de .NET Framework equivalentes.
typeof ( expression )
se transforma en:
System.Type.GetType( expression )
El depurador evalúa entonces esta expresión transformada.
El depurador admite el operador sizeof.
WebMethods
No se puede llamar a WebMethods desde las ventanas del depurador.