Espressioni in C# e F#
L'analizzatore di espressioni gestite accetta la maggior parte delle espressioni scritte in C#.
L'analizzatore di espressioni gestito non riconosce le espressioni F#, tuttavia.Se si esegue il debug di F#, è necessario tradurre le espressioni nella sintassi C# prima di immettere le espressioni una finestra di dialogo del debugger o in una finestra.Quando si traducono espressioni da F# a C#, assicurarsi di ricordare che C# utilizzi l'operatore == operatore per verificare l'uguaglianza, mentre F# utilizza il singolo =.
Nelle sezioni riportate di seguito vengono fornite informazioni specifiche e vengono illustrati alcuni tipi di espressioni non supportati o parzialmente supportati:
Casts
Dynamic Objects
Identifiers and Types
Method Evaluation
Operators
Overloaded Operators
Property Evaluation
Strings
typeof and sizeof Operators
WebMethods
L'analizzatore di espressioni ignora public, protected, internal e i modificatori di accesso private .È ad esempio possibile chiamare un metodo private dalla finestra Espressioni di controllo.Poiché l'analizzatore di espressioni ignora i modificatori di accesso, è possibile che venga richiamato un carico imprevisto.
L'analizzatore di espressioni esegue tutte le valutazioni in un contesto unsafe implicito, indipendentemente dal fatto che il codice eseguito sia di tipo safe o unsafe.
L'analizzatore di espressioni ignora inoltre i blocchi checked e l'opzione del compilatore /checked.Tutte le espressioni vengono valutate in un contesto unchecked.
È possibile personalizzare la visualizzazione di tipi di dati personalizzati tramite l'utilizzo di attributi.Per ulteriori informazioni, vedere Visualizzazione di tipi di dati personalizzati.
Cast
Nel debugger possono essere utilizzate espressioni cast semplici:
(A)x
I cast che implicano l'utilizzo di puntatori non funzionano nel debugger.
Oggetti dinamici
L'analizzatore di espressioni può valutare variabili che sono digitate staticamente come dinamiche.Può valutare anche oggetti che implementano l'interfaccia IDynamicObject.Quando gli oggetti che implementano l'interfaccia IDynamicObject vengono valutati nella finestra Espressioni di controllo, viene aggiunto un nodo Visualizzazione dinamica.Il nodo di visualizzazione dinamica mostra i membri dell'oggetto ma non consente la modifica dei valori dei membri.
Le seguenti funzionalità di oggetti dinamici non sono supportate:
Gli operatori composti +=, -=, %=, /= e *=
Molti cast, inclusi cast numerici e cast dell'argomento di tipo
Chiamate al metodo con più di due argomenti
I metodi per il richiamo delle proprietà con più di due argomenti
I metodi per il richiamo delle proprietà con gli argomenti
Assegnazione a un indicizzatore
Operatori booleani && e ||.
Identificatori e tipi
Nelle espressioni del debugger è possibile utilizzare qualsiasi identificatore visibile nell'ambito corrente.Se, ad esempio, il debugger viene arrestato nel metodo Magh, è possibile utilizzare qualsiasi identificatore visibile all'interno di Magh, tra cui costanti, nomi di variabili e nomi di metodi.
Nel debugger è possibile visualizzare correttamente qualsiasi variabile di tipo primitivo, enum o intrinseco.Nel caso di variabili di tipo classe, il valore viene visualizzato correttamente in base al tipo derivato di livello più basso.Se si dispone di un oggetto leo di tipo Lion derivato dal tipo Cat, è possibile valutare leo.Claws e ottenere il valore corretto per un oggetto di tipo Lion.
È possibile assegnare un nuovo valore a qualsiasi espressione nella parte sinistra che è un l-value,inclusi i tipi primitivo, classe e System.Object.
Valutazione dei metodi
Il debugger supporta la valutazione dei metodi, tra cui quelli di overload.Di conseguenza, quando si immette una delle espressioni seguenti, il debugger chiama la versione corretta dei metodi di overload:
Time.Set();
Time.Set(atime);
La valutazione di un metodo nel debugger comporta la chiamata e l'esecuzione del codice relativo a tale metodo.Se il metodo genera effetti collaterali, la valutazione del metodo in una finestra del debugger comporterà la modifica dello stato del programma e questa operazione può produrre risultati imprevisti.
Quando si imposta un punto di interruzione su un metodo di overload, la posizione del punto di interruzione dipende dal modo in cui si specifica il metodo.Se si specifica la firma completa, ossia il nome del metodo e l'elenco completo degli argomenti, verrà impostato un punto di interruzione sull'overload specificato.Se si specifica solo il nome del metodo, il comportamento del debugger dipenderà da un'impostazione delle opzioni di Visual Studio.Se la casella di controllo Usa IntelliSense per verificare il nome della funzione è deselezionata, il debugger imposterà un punto di interruzione su ogni overload di tale nome.In caso contrario, verrà visualizzata la finestra di dialogo Seleziona punti di interruzione nella quale è possibile specificare gli overload su cui si desidera inserire il punto di interruzione.Per ulteriori informazioni, vedere Procedura: impostare un punto di interruzione di funzione.
La creazione di nuovi metodi anonimi non è supportata nel debugger di questa versione di Visual Studio.
Operatori
Nel debugger viene eseguita correttamente la valutazione della maggior parte degli operatori incorporati, tra cui:
Operatori relazionali e di uguaglianza: (expr1> expr2, expr1< expr2, expr1<= expr2, expr1=> expr2, expr1== expr2, expr1!= expr2).
Operatori booleani: (expr1&& expr2, expr1|| expr2, expr1? expr2: expr3).
Operatori aritmetici: (expr1+expr2,expr1-expr2, expr1*expr2, expr1/expr2, expr1%expr2 ).
Operatori logici: (expr1& expr2, expr1^ expr2, expr1| expr2).
Operatori shift: (expr1>> expr2, expr1<< expr2).
Operatori di assegnazione: ( lvalue=expr2,lvalue*=expr2,lvalue/=expr2, lvalue%=expr2, lvalue+=expr2, lvalue-=expr2, lvalue<<=expr2, lvalue>>=expr2, lvalue&=expr2, lvalue^=expr2, lvalue|=expr2).
Operatori unari: (+expr1, - expr1, expr1++, ++expr1, expr1--, --expr1).
Operatori di overload
Nel debugger è possibile utilizzare la maggior parte degli operatori di overload.
Gli operatori infissi di overload +, -, /, %, e & sono supportati:
+ expr1+ expr2
+ expr1- expr2
+ expr1/ expr2
+ expr1% expr2
+ expr1& expr2
Gli operatori infissi di overload =, &&, & e || non sono supportati:
+ expr1= expr2
+ expr1&& expr2
+ expr1& expr2
+ expr1|| expr2
Gli operatori infissi di overload << e >> non sono supportati se entrambi gli operandi sono variabili di classe:
object1 <<object2
oggetto1>> oggetto2
Gli operatori prefissi di overload +, -, ++, --, ! e ~ sono supportati:
++ expr1
-+ expr1
+++ expr1
--+ expr1
!+ expr1
~+ expr1
Gli operatori suffissi di overload ++ e -- sono supportati:
+ expr1++
+ expr1--
Gli indicizzatori di overload sono supportati:
- + expr1[expr2]
Valutazione delle proprietà
Il debugger è in grado di valutare le proprietà in qualsiasi finestra di variabile.La valutazione di una proprietà nel debugger può tuttavia produrre effetti collaterali che generano risultati imprevisti e indesiderati.Per evitare gli effetti collaterali causati da una valutazione accidentale, è possibile disattivare la valutazione delle proprietà nella finestra di dialogo Opzioni.
Stringhe
Quando utilizzato con stringhe e matrici, l'operatore di indice viene riconosciuto.È ad esempio possibile digitare:
"hello world"[0]
Nella finestra Espressioni di controllo verrà visualizzato il valore corretto:
'h'
A differenza di quanto avviene nel linguaggio C/C++ nativo, in C# è possibile modificare il valore di una stringa nel debugger.Inoltre, è possibile utilizzare l'operatore Length su una stringa:
mystring.Length
In alternativa
"hello world".Length
In C# è possibile concatenare stringhe:
"hello" + "world"
Operatori typeof e sizeof
Il debugger supporta gli operatori typeof e sizeof, che vengono trasformati nella funzione .NET Framework equivalente.
typeof ( espressione)
viene trasformato in:
System.Type.GetType( espressione)
Viene quindi valutata l'espressione trasformata.
Il debugger supporta l'operatore sizeof.
WebMethod
Non è possibile chiamare WebMethod dalle finestre del debugger.