Espressioni in C# e F#

Le informazioni contenute in questo argomento sono valide per:

Edizione	Visual Basic	C#	F#	C++	Web Developer
Express
Pro, Premium e Ultimate

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:

• Cast

• Oggetti dinamici

• Identificatori e tipi

• Valutazione dei metodi

• Operatori

• Operatori di overload

• Valutazione delle proprietà

• Stringhe

• Operatori typeof e sizeof

• WebMethod

• 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

• object1 >> object2

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 ( expression )

viene trasformato in:

System.Type.GetType( expression )

Viene quindi valutata l'espressione trasformata.

Il debugger supporta l'operatore sizeof.

WebMethod

Non è possibile chiamare WebMethod dalle finestre del debugger.

Vedere anche

Altre risorse

Espressioni nel debugger

C# Reference