Condividi tramite

Debug di LINQ

  • Articolo

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, tra cui l'esecuzione dei passaggi, 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 DataTips, la finestra Osserva e la finestra di dialogo Controllo rapido. Quando si utilizza una finestra sorgente, è possibile sospendere il puntatore su una query nella finestra sorgente e verrà visualizzato un DataTip. È possibile copiare una variabile LINQ e incollarla nella finestra Controllo o nella finestra di dialogo Controllo rapido.

In LINQ una query non viene valutata quando viene creata o dichiarata, ma solo quando viene usata. Pertanto, finché non viene valutata, la query non ha un valore. Per una descrizione completa della creazione e della valutazione delle query, vedere Introduzione alle query LINQ (C#) o Scrittura della 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 una notevole riduzione delle 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 query 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.

Esecuzione di istruzioni e LINQ

Quando si esegue il debug del codice LINQ, il passaggio presenta alcune differenze comportamentali che è necessario conoscere.

LINQ to SQL

Nelle query LINQ to SQL il codice del predicato esula dal controllo del debugger. Pertanto, non è possibile eseguire l'istruzione nel codice del predicato. Qualsiasi query compilata in un albero delle espressioni produce codice che esula dal controllo del debugger.

Esecuzione passo-passo in Visual Basic

Quando si utilizza un programma Visual Basic e il debugger rileva un'espressione di query, non vi entra ma evidenzia l'intera dichiarazione come singola 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 prosegue attraverso il codice di esempio seguente, il debugger evidenzia la dichiarazione di query o la creazione di query come un'unica 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 a Console.WriteLine(cur.ToSting()). In nessun momento viene eseguito il passaggio attraverso il codice del predicato nella dichiarazione di query, anche se il debugger valuta tale codice.

Sostituzione di un predicato con una funzione per consentire il passaggio (Visual Basic)

Se devi eseguire passo passo il codice del predicato per scopi di debug, puoi 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 iterazione attraverso il 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 Cambiamenti supportati da EnC

Contenuto correlato