Expresiones en C# y F#
Este tema se aplica a:
Edición |
Visual Basic |
C# |
F# |
C++ |
Web Developer |
|---|---|---|---|---|---|
Express |
.gif "El tema no es aplicable") |
.gif "El tema es aplicable") |
|
|
|
Pro, Premium y Ultimate |
|
|
|
|
|
El evaluador de expresiones administradas acepta la mayoría de las expresiones escritas en C#.
El evaluador de expresiones administradas no reconoce las expresiones F#, sin embargo. Si está depurando F#, debe traducir sus expresiones a la sintaxis de C# antes de introducir las expresiones en una ventana de depurador o cuadro de diálogo. Al traducir las expresiones de F# a C#, asegúrese de recordar que C# utiliza el operador == para comprobar la igualdad, mientras que F# utiliza solo =.
Las secciones siguientes ofrecen información específica y tratan algunos de los tipos de expresión no compatibles o parcialmente compatibles:
Conversiones de tipo
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 . Puede llamar a un método private desde la ventana Inspección, por ejemplo. Dado 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 desactivado.
Puede personalizar la presentación de los tipos de datos personalizados utilizando atributos. Para obtener más información, vea Presentación de tipos de datos personalizados.
Conversiones de tipo
En el depurador, funcionan expresiones de conversión de tipos sencillas:
(A)x
Las conversiones que afectan a punteros no funcionan en el depurador.
Objetos dinámicos
El evaluador de expresiones puede evaluar variables con tipos estáticos como dinámicas. 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 del objeto pero no permite la edición de los valores de los miembros.
No se admiten las características siguientes de objetos dinámicos:
Los operadores compuestos +=, -=, %=, /= y *=
Muchas conversiones de tipos, incluidas las conversiones numéricas y las conversiones de argumentos de tipos
Llamadas al método con más de dos argumentos
Captadores de propiedades con más de dos argumentos
Establecedores de propiedades con argumentos
Asignar a un indizador
Operadores booleanos && y ||
Identificadores y tipos
Las expresiones del depurador pueden utilizar cualquier identificador visible en el ámbito actual. Si se detiene el depurador en el método Magh, por ejemplo, puede utilizar cualquier identificador visible en Magh, incluidos las constantes, los nombres de variable y los nombres de método.
El depurador puede mostrar correctamente cualquier variable de tipo primitive, enum o intrinsic. Para variables de tipo class, 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 del objeto de tipo Lion.
Puede asignar un nuevo valor a cualquier expresión del lado izquierdo que sea un valor l. Esto incluye los tipos primitivo, clase y System.Object.
Evaluación de métodos
El depurador es compatible con la evaluación de métodos, incluidos los métodos sobrecargados. Por tanto, se puede escribir cualquiera de las siguientes expresiones 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 firma completa (nombre de método y lista de argumentos completa), el depurador establecerá un punto de interrupción en la sobrecarga especificada. Si especifica sólo el nombre del método, el comportamiento del depurador dependerá de una configuración de 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 puede especificar las sobrecargas en las que desea establecer el punto de interrupción. Para obtener más información, vea Cómo: Establecer un punto de interrupción de función.
La creación de nuevos métodos anónimos no se admite 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 infijos sobrecargados +, -, /, % y &:
expr1 + expr2
+ expr1 - expr2
expr1 / expr2
expr1 % expr2
expr1 & expr2
Los operadores infijos sobrecargados =, &&, & y || no funcionan:
expr1 = expr2
expr1 && expr2
expr1 & expr2
expr1 || expr2
Los operadores de infijo sobrecargados <<and>> no funcionan si ambos operandos son variables de clase:
objeto1 <<objeto2
objeto1 >> objeto2
Los operadores prefijos sobrecargados +, -, ++, --, ! y ~ funcionan:
+ expr1
expr1-
expr1++
expr1--
expr1!
expr1~
Los operadores sufijos sobrecargados ++ y -- funcionan:
expr1 ++
expr1 --
Los indizadores sobrecargados funcionan:
- expr1 [ expr2 ]
Evaluación de propiedades
El depurador puede evaluar propiedades en cualquier ventana de variable. Sin embargo, evaluar una propiedad en el depurador puede tener efectos secundarios que produzcan resultados inesperados y no deseados. Para proteger 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++ nativos, puede modificar 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 es compatible con los operadores typeof y sizeof al transformarlos en las funciones de .NET Framework equivalentes.
typeof ( expresión )
se transforma en:
System.Type.GetType( expresión )
El depurador evalúa esta expresión transformada.
El depurador es compatible con el operador sizeof.
WebMethods
No se puede llamar a WebMethods desde las ventanas del depurador.