Notes
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Les alias de fonction sont un nom court unique par lequel un utilisateur du débogueur peut accéder aux fonctionnalités définies dans une extension de débogueur (écrit en C++ ou dans un environnement de script tel que JavaScript). Ce nom court est associé à un objet de fonction de modèle de données (objet qui implémente IModelMethod). Cette fonction prend un nombre arbitraire d’arguments et retourne une valeur unique. L’effet de l’appel d’un alias de fonction et de ce qui est fait avec cette valeur dépend de la façon dont l’alias de fonction est appelé et du débogueur hôte dans lequel il est appelé.
Cette rubrique suppose que le lecteur est familiarisé avec le modèle objet du débogueur et JavaScript. Pour plus d’informations sur l’utilisation d’objets de débogueur avec JavaScript, consultez objets de débogueur natifs dans les extensions JavaScript.
Certains exemples présentés ici utilisent la commande dx, pour plus d’informations sur l’utilisation de la commande dx, consultez dx (Display Debugger Object Model Expression). En outre, LINQ est utilisé, qui est décrit dans Utilisation de LINQ With les objets de débogueur.
Utilisation de l’alias de fonction comme commandes d’extension
Tous les alias de fonction créés dans WinDbg peuvent être appelés comme s’ils étaient l’extension de débogage ! commandes « bang ». Si la fonction ne prend pas d’arguments, l’appel de !aliasName entraîne l’appel de la fonction et la valeur du résultat s’affiche. Par exemple (créé avec l’extensibilité JavaScript)
Par exemple, cette fonction fournit deux valeurs constantes, pi et e.
function __constants()
{
return { math_constants : { pi : 3.1415926535 , e : 2.7182818284}, description : "Archimedes' pi and Euler's number e" };
}
function initializeScript()
{
return [new host.functionAlias(__constants, "constants")];
}
Les résultats de l’appel de l’alias de fonction sont affichés ici.
0:000> !constants
@$constants() : [object Object]
math_constants : [object Object]
description : Archimedes' pi and Euler's number e
Les liens DML vers des objets complexes sont générés automatiquement. Si vous cliquez sur le math_constants indiqué ci-dessus, la sortie suivante s’affiche.
0:000> dx -r1 @$constants().math_constants
@$constants().math_constants : [object Object]
pi : 3.141593
e : 2.718282
Si la fonction a des arguments, elles peuvent être fournies après la commande alias de fonction elle-même. Notez que tout ce qui vient après la commande d’alias de fonction est considéré comme une expression et est évalué comme tel. La chaîne de texte n’est pas transmise directement à la fonction. Pour une expression d’argument unique, elle peut venir après la commande d’alias de fonction elle-même. Pour plusieurs arguments, ils doivent être entre parenthèses comme s’il s’agissait d’un appel de fonction comme illustré dans cet exemple suivant.
function __oneArgument(x)
{
return -x;
}
function __twoArguments(x, y)
{
return x + y;
}
function initializeScript()
{
return [new host.functionAlias(__oneArgument, "neg"),
new host.functionAlias(__twoArguments, "add")];
}
Ces deux fonctions peuvent être appelées comme indiqué ici.
0:000> !neg 42
@$neg(42) : -42
0:000> !add (5, 7)
@$add(5, 7) : 0xc
Utilisation de l’alias de fonction avec l’évaluateur d’expression dx
En plus de l’extension de débogage ! syntaxe de commande « bang » pour appeler une fonction alias, tous les noms associés aux alias de fonction sont directement disponibles dans l’évaluateur d’expression dx lorsqu’ils sont préfixés par @$ comme indiqué ici.
0:000> dx @$neg(42)
@$neg(42) : -42
0:000> dx @$add(99, 77)
@$add(99, 77) : 0xb0
Considérations relatives à la conception des alias de fonction
Un alias de fonction ne doit jamais être la seule façon dont les fonctionnalités de la grande majorité des extensions de modèle de données sont exposées. Une extension de modèle de données (qu’elle soit en C++ ou JavaScript) doit presque toujours inclure les données qu’elle expose associées à un type ou à un autre concept de débogueur. Les éléments associés aux processus doivent se trouver sous Debugger.Models.Process ou sous-espace de noms de cet objet. Un alias de fonction peut être un moyen pratique d’obtenir (ou de transformer) des données qui peuvent nécessiter une requête beaucoup plus longue.
Comme exemple de mode noyau, la requête suivante prend l’arborescence d’appareils PnP et l’aplatit dans une liste plate simple d’appareils :
0: kd> dx @$cursession.Devices.DeviceTree.Flatten(n => n.Children),5
@$cursession.Devices.DeviceTree.Flatten(n => n.Children),5
[0x0] : HTREE\ROOT\0
[0x1] : ROOT\volmgr\0000 (volmgr)
[0x2] : ROOT\BasicDisplay\0000 (BasicDisplay)
[0x3] : ROOT\CompositeBus\0000 (CompositeBus)
[0x4] : ROOT\vdrvroot\0000 (vdrvroot)
[...]
Ce code JavaScript montre comment cela peut être implémenté en tant qu’alias de fonction.
function __flatDevices()
{
return host.currentSession.Devices.DeviceTree.Flatten(n => n.Children);
}
function initializeScript()
{
return [new host.functionAlias(__flatDevices, "devices")];
}
L’alias de fonction peut ensuite être appelé en tant que commande d’extension de débogage.
0: kd> !devices
@$devices()
[0x0] : HTREE\ROOT\0
[0x1] : ROOT\volmgr\0000 (volmgr)
[0x2] : ROOT\BasicDisplay\0000 (BasicDisplay)
[0x3] : ROOT\CompositeBus\0000 (CompositeBus)
[0x4] : ROOT\vdrvroot\0000 (vdrvroot)
[0x5] : ROOT\spaceport\0000 (spaceport)
...
L’un des avantages liés à l’utilisation d’un alias de fonction est qu’il peut être affiné à l’aide de la syntaxe dx. Dans cet exemple, une clause where est ajoutée pour rechercher les nœuds d’appareil qui contiennent « Harddisk ».
0: kd> dx @$devices().Where(n => n.InstancePath.Contains("Harddisk"))
@$devices().Where(n => n.InstancePath.Contains("Harddisk"))
[0x0] : STORAGE\VolumeSnapshot\HarddiskVolumeSnapshot1
[0x1] : STORAGE\VolumeSnapshot\HarddiskVolumeSnapshot2
[0x2] : STORAGE\VolumeSnapshot\HarddiskVolumeSnapshot3
[0x3] : STORAGE\VolumeSnapshot\HarddiskVolumeSnapshot4
[0x4] : STORAGE\VolumeSnapshot\HarddiskVolumeSnapshot5
[0x5] : STORAGE\VolumeSnapshot\HarddiskVolumeSnapshot6
Les commandes LINQ telles que les suivantes peuvent être utilisées avec des alias fonctionnels : . Tout. Quelconque. Compter. Premier. Aplatir. GroupBy, . Dernier. OrderBy, . OrderByDescending, . Sélectionnez, puis . Où. Ces méthodes suivent (le plus étroitement possible) le formulaire de méthode LINQ C#. Pour plus d’informations, consultez Utilisation de LINQ with the debugger objects.
grille d’affichage
Comme avec d’autres commandes dx, vous pouvez cliquer avec le bouton droit sur une commande une fois qu’elle a été exécutée, puis cliquer sur « Afficher en tant que grille » ou ajouter « -g » à la commande pour obtenir une vue grille des résultats. Vous pouvez ensuite cliquer sur n’importe quelle colonne pour trier, par exemple sur InstancePath.
0: kd> dx -g @$devices().OrderBy(obj => obj.@"InstancePath")
Exemple de threads de processus
Les objets du débogueur sont projetés dans un espace de noms rooté sur « Débogueur ». Les processus, les modules, les threads, les piles, les trames de pile et les variables locales sont tous disponibles pour être utilisés dans une requête LINQ.
Cet exemple JavaScript montre comment afficher le nombre de threads pour les processus de sessions actuelles :
function __Processes()
{
return host.currentSession.Processes.Select(p => ({Name: p.Name, ThreadCount: p.Threads.Count()}));
}
function initializeScript()
{
return [new host.functionAlias(__Processes, "Processes")];
}
Cela montre l’exemple de sortie avec le ! Traite l’alias de fonction.
0: kd> !Processes
@$Processes()
[0x0] : [object Object]
[0x4] : [object Object]
[0x1b4] : [object Object]
[0x248] : [object Object]
[0x2c4] : [object Object]
[0x340] : [object Object]
[0x350] : [object Object]
[0x3d4] : [object Object]
[0x3e8] : [object Object]
[0x4c] : [object Object]
[0x214] : [object Object]
[0x41c] : [object Object]
[0x494] : [object Object]
...
Dans cet exemple, le premier processus 5 avec le plus grand nombre de threads s’affiche.
0: kd> dx -r1 @$Processes().OrderByDescending(p =>p.ThreadCount),5
@$Processes().OrderByDescending(p =>p.ThreadCount),5
[0x4] : [object Object]
[0x180] : [object Object]
[0x978] : [object Object]
[0xda4] : [object Object]
[0x3e8] : [object Object]
[...]
Voir aussi
dx (afficher l’expression de modèle objet du débogueur)
utilisation de LINQ with the debugger objects
objets débogueur natifs dans natVis
objets débogueur natifs dans les extensions JavaScript