Partager via

Débogage LINQ

  • Article

Visual Studio prend en charge le débogage du code LINQ (Language Integrated Query), avec certaines limitations. La plupart des fonctionnalités de débogage fonctionnent avec des instructions LINQ, notamment l’exécution pas à pas, la définition de points d’arrêt et l’affichage des résultats dans les fenêtres du débogueur. Cette rubrique décrit les principales limitations du débogage LINQ.

Affichage des résultats LINQ

Vous pouvez afficher le résultat d’une instruction LINQ à l’aide de DataTips, de la fenêtre Espion et de la boîte de dialogue Espion rapide. Lorsque vous utilisez une fenêtre source, vous pouvez suspendre le pointeur sur une requête dans la fenêtre source pour afficher un DataTip. Vous pouvez copier une variable LINQ et la coller dans la fenêtre Espionnage ou dans la boîte de dialogue Espionnage rapide.

Dans LINQ, une requête n’est pas évaluée lorsqu’elle est créée ou déclarée, mais uniquement lorsque la requête est utilisée. Par conséquent, la requête n’a pas de valeur tant qu’elle n’est pas évaluée. Pour obtenir une description complète de la création et de l’évaluation des requêtes, consultez Présentation des requêtes LINQ (C#) ou Écriture de votre première requête LINQ.

Pour afficher le résultat d’une requête, le débogueur doit l’évaluer. Cette évaluation implicite, qui se produit lorsque vous affichez un résultat de requête LINQ dans le débogueur, a des effets que vous devez prendre en compte :

  • Chaque évaluation de la requête prend du temps. Le développement du nœud de résultats prend du temps. Pour certaines requêtes, une évaluation répétée peut entraîner une pénalité de performances notable.

  • L’évaluation d’une requête peut entraîner des effets secondaires, qui sont des modifications apportées à la valeur des données ou à l’état de votre programme. Toutefois, les requêtes ne présentent pas toutes des effets secondaires. Pour déterminer si une requête peut être évaluée en toute sécurité sans effets secondaires, vous devez comprendre le code qui implémente la requête.

Exécution pas à pas et LINQ

Lorsque vous déboguez du code LINQ, l'exécution pas à pas présente des différences comportementales que vous devriez connaître.

LINQ to SQL

Dans les requêtes LINQ to SQL, le code de prédicat dépasse le contrôle du débogueur. Par conséquent, vous ne pouvez pas passer au code de prédicat. Toute requête qui se compile dans une arborescence d’expressions produit du code qui dépasse le contrôle du débogueur.

Exécution pas à pas dans Visual Basic

Lorsque vous effectuez un pas à pas dans un programme Visual Basic et que le débogueur rencontre une déclaration de requête, il ne pénètre pas dans la déclaration, mais met en évidence l’intégralité de la déclaration comme une seule instruction. Ce comportement se produit parce que la requête n’est pas évaluée tant qu’elle n’est pas appelée. Pour plus d’informations, consultez Présentation de LINQ dans Visual Basic.

Si vous parcourez l’exemple de code suivant, le débogueur met en surbrillance la déclaration de requête ou la création d’une requête en tant qu’instruction unique.

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

Lors de la prochaine exécution pas à pas, le débogueur met en surbrillance For Each cur In x. À l’étape suivante, elle passe à la fonction MyFunction. Après l’exécution de MyFunction pas à pas, il revient à Console.WriteLine(cur.ToSting()). À aucun moment, le débogueur n'effectue de pas à pas détaillé du code de prédicat dans la déclaration de requête, alors même qu'il évalue ce code.

Remplacement d’un prédicat par une fonction pour activer l’exécution pas à pas (Visual Basic)

Si vous devez parcourir le code de prédicat à des fins de débogage, vous pouvez remplacer le prédicat par un appel à une fonction qui contient le code de prédicat d’origine. Par exemple, supposons que vous ayez ce code :

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

Vous pouvez déplacer le code de prédicat vers une nouvelle fonction, appelée 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 requête révisée appelle la fonction IsEven pour chaque passage via le items. Vous pouvez utiliser les fenêtres du débogueur pour vérifier si chaque élément répond à la condition spécifiée, et vous pouvez également parcourir le code dans IsEven. Le prédicat de cet exemple est assez simple. Toutefois, si vous avez un prédicat plus difficile à déboguer, cette technique peut être très utile.

La fonctionnalité 'Modifier et continuer' n'est pas prise en charge pour LINQ

Modifier et continuer prend en charge les modifications apportées aux requêtes LINQ avec des limitations. Pour plus d’informations, consultez Modifications prises en charge par EnC

Contenu connexe