Debug di LINQ
Visual Studio supporta il debug del codice LINQ (Language Integrated Query), con alcune limitazioni. La maggior parte delle funzionalità di debug funziona con le istruzioni LINQ, inclusi il passaggio, l'impostazione di punti di interruzione e la visualizzazione dei risultati nelle finestre del debugger. In questo argomento vengono descritte le limitazioni principali del debug LINQ.
Visualizzazione dei risultati LINQ
È possibile visualizzare il risultato di un'istruzione LINQ usando Suggerimenti dati, la finestra Osservazione e la finestra di dialogo Controllo rapido. Quando si usa una finestra di origine, è possibile posizionare il puntatore su una query nella finestra di origine e verrà visualizzato un DataTip. È possibile copiare una variabile LINQ e incollarla nella finestra 'Osserva' o nella finestra di dialogo 'Esplora Rapidamente'.
In LINQ una query non viene valutata quando viene creata o dichiarata, ma solo quando viene usata la query. Pertanto, la query non ha un valore finché non viene valutata. Per una descrizione completa della creazione e della valutazione delle query, vedere Introduzione alle query LINQ (C#) o Scrivere la prima query LINQ.
Per visualizzare il risultato di una query, il debugger deve valutarlo. Questa valutazione implicita, che si verifica quando si visualizza il risultato di una query LINQ nel debugger, ha alcuni effetti da considerare:
Ogni valutazione della query richiede tempo. L'espansione del nodo dei risultati richiede tempo. Per alcune query, la valutazione ripetuta potrebbe comportare un impatto significativo sulle prestazioni.
La valutazione di una query può comportare effetti collaterali, che sono modifiche al valore dei dati o allo stato del programma. Non tutte le interrogazioni hanno effetti collaterali. Per determinare se una query può essere valutata in modo sicuro senza effetti collaterali, è necessario comprendere il codice che implementa la query.
Procedura passo-passo e LINQ
Quando esegui il debug di codice LINQ, l'esecuzione passo a passo presenta alcune differenze comportamentali che dovresti conoscere.
LINQ to SQL
Nelle query LINQ to SQL il codice del predicato esula dal controllo del debugger. Pertanto, non è possibile entrare nel codice del predicato. Qualsiasi query compilata in un albero delle espressioni produce codice che esula dal controllo del debugger.
Avanzamento in Visual Basic
Quando si esegue un programma Visual Basic e il debugger rileva una dichiarazione di query, non entra nella dichiarazione ma evidenzia l'intera dichiarazione come un'unica istruzione. Questo comportamento si verifica perché la query non viene valutata finché non viene chiamata. Per altre informazioni, vedere Introduzione a LINQ in Visual Basic.
Se si esegue il codice di esempio seguente, il debugger evidenzia la dichiarazione di query o la creazione di query come singola istruzione.
Function MyFunction(ByVal x As Char)
Return True
End Function
Sub Main()
'Query creation
Dim x = From it In "faoaoeua" _
Where MyFunction(it) _
Select New With {.a = it}
' Query execution
For Each cur In x
Console.WriteLine(cur.ToString())
Next
End Sub
Quando si esegue di nuovo il passaggio, il debugger evidenzia For Each cur In x. Nel passaggio successivo passa alla funzione MyFunction. Dopo essere passato attraverso MyFunction, torna indietro a Console.WriteLine(cur.ToSting()). In nessun momento si passa attraverso il codice del predicato nella dichiarazione di query, anche se il debugger valuta tale codice.
Sostituzione di un predicato con una funzione per abilitare le istruzioni (Visual Basic)
Se è necessario eseguire il codice del predicato per scopi di debug, è possibile sostituire il predicato con una chiamata a una funzione che contiene il codice del predicato originale. Si supponga, ad esempio, di avere questo codice:
Dim items() as integer ={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
' Get the even numbers
Dim query = From nextInt in items Where nextInt Mod 2 = 0 Select nextInt
For each item in query
Console.WriteLine(item)
Next
È possibile spostare il codice del predicato in una nuova funzione, denominata IsEven:
Dim items () as integer ={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
' Get the even numbers
Dim query = From nextInt in items Where IsEven(nextInt) Select nextInt
For each item in query
Console.WriteLine(item)
Next
...
Function IsEven(item As =Integer) as Boolean
Return item Mod 2 = 0
End Function
La query modificata chiama la funzione IsEven a ogni passaggio del items. È possibile usare le finestre del debugger per verificare se ogni elemento soddisfa la condizione specificata ed è possibile eseguire il codice in IsEven. Il predicato in questo esempio è piuttosto semplice. Tuttavia, se è necessario eseguire il debug di un predicato più difficile, questa tecnica può essere molto utile.
Modifica e continuazione non supportate per LINQ
Modifica e Continuazione supporta le modifiche alle query LINQ con limitazioni. Per informazioni dettagliate, vedere modifiche supportate da EnC