Debugger-gegevensmodel-functie-aliasen

Artikel
2025-03-27

Functiealiassen zijn een unieke korte naam waarmee een gebruiker van het foutopsporingsprogramma toegang heeft tot functionaliteit die is gedefinieerd in een foutopsporingsprogramma-extensie (zowel geschreven in C++ als in een scriptomgeving zoals JavaScript). Deze korte naam wordt gekoppeld aan een gegevensmodelfunctieobject (een object dat IModelMethod implementeert). Deze functie gebruikt een willekeurig aantal argumenten en retourneert één waarde. Het effect van het aanroepen van een functiealias en wat er met die waarde gebeurt, is afhankelijk van hoe de functiealias wordt aangeroepen en in welk hostdebugger het wordt aangeroepen.

In dit onderwerp wordt ervan uitgegaan dat de lezer bekend is met het objectmodel voor foutopsporingsprogramma's en JavaScript. Zie Native Debugger Objects in JavaScript Extensionsvoor meer informatie over het gebruik van foutopsporingsprogrammaobjecten met JavaScript.

Sommige voorbeelden die hier worden weergegeven, gebruiken de dx-opdracht, voor meer informatie over het werken met de dx-opdracht, zie dx (Display Debugger Object Model Expression). Daarnaast wordt de LINQ gebruikt die wordt beschreven in LINQ gebruiken met de foutopsporingsprogrammaobjecten.

Functiealias gebruiken als extensieopdrachten

Alle functiealiassen die in WinDbg zijn gemaakt, kunnen worden aangeroepen alsof ze de foutopsporingsextensie ! 'bang'-opdrachten. Als de functie geen argumenten gebruikt, zorgt het aanroepen van !aliasName ervoor dat de functie wordt aangeroepen en dat de resultaatwaarde wordt weergegeven. Als voorbeeld (gemaakt met JavaScript-uitbreidbaarheid)

Deze functie biedt bijvoorbeeld twee constante waarden, pi en 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")];
}

De resultaten van het aanroepen van de functiealias worden hier weergegeven.

0:000> !constants
@$constants()                 : [object Object]
    math_constants   : [object Object]
    description      : Archimedes' pi and Euler's number e

DML-koppelingen naar complexe objecten worden automatisch gegenereerd. Als u op de hierboven weergegeven math_constants klikt, wordt de volgende uitvoer weergegeven.

0:000> dx -r1 @$constants().math_constants
@$constants().math_constants                 : [object Object]
    pi               : 3.141593
    e                : 2.718282

Als de functie argumenten heeft, kunnen deze worden opgegeven na de opdracht voor de functiealias zelf. Houd er rekening mee dat alles na de opdracht functiealias wordt beschouwd als een expressie en als zodanig wordt geëvalueerd. De tekenreeks wordt niet rechtstreeks doorgegeven aan de functie. Voor één argumentexpressie kan deze komen na de opdracht functiealias zelf. Voor meerdere argumenten moeten ze tussen haakjes worden geplaatst alsof het een functie-aanroep was, zoals geïllustreerd in dit volgende voorbeeld.

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")];
}

Deze twee functies kunnen worden aangeroepen, zoals hier wordt weergegeven.

0:000> !neg 42
@$neg(42)        : -42

0:000> !add (5, 7)
@$add(5, 7)      : 0xc

Functiealias gebruiken met de dx-expressie-evaluator

Naast de foutopsporingsextensie ! 'bang'-opdrachtsyntaxis voor het aanroepen van een aliasfunctie, zijn alle namen die zijn gekoppeld aan functiealiassen, rechtstreeks beschikbaar in de dx-expressie-evaluator wanneer deze wordt voorafgegaan door @$, zoals hier wordt weergegeven.

0:000> dx @$neg(42)
@$neg(42)        : -42

0:000> dx @$add(99, 77)
@$add(99, 77)    : 0xb0

Overwegingen bij ontwerp van functiealias

Een functiealias mag nooit de enige manier zijn waarop functionaliteit in de overgrote meerderheid van gegevensmodelextensies beschikbaar wordt gemaakt. Een gegevensmodelextensie (in C++ of JavaScript) moet bijna altijd de gegevens bevatten die zijn gekoppeld aan een type of ander foutopsporingsprogramma. Items die zijn gekoppeld aan processen, moeten zich onder Debugger.Models.Process of een subnaamruimte van dat object bevinden. Een functiealias kan een handige manier zijn om gegevens te verkrijgen (of te transformeren) waarvoor mogelijk een aanzienlijk langere query nodig is.

Als voorbeeld van een kernelmodus neemt de volgende query de PnP-apparaatstructuur en wordt deze platgemaakt in een eenvoudige platte lijst met apparaten:

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)
    [...]

Deze JavaScript-code laat zien hoe dit kan worden geïmplementeerd als een functiealias.

function __flatDevices()
{
    return host.currentSession.Devices.DeviceTree.Flatten(n => n.Children);
}

function initializeScript()
{
    return [new host.functionAlias(__flatDevices, "devices")];
}

De functiealias kan vervolgens worden aangeroepen als een opdracht voor foutopsporingsextensie.

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)

    ...

Een van de voordelen van het gebruik van een functiealias is dat deze verder kan worden verfijnd met behulp van de dx-syntaxis. In dit voorbeeld wordt een where-component toegevoegd om te zoeken naar apparaatknooppunten die 'Harddisk' bevatten.

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

LINQ-opdrachten zoals de volgende kunnen worden gebruikt met functionele aliassen - . Alle. Enig. Tellen. Eerste. Pletten. GroupBy, . Laatste. OrderBy, . OrderByDescending, . Selecteer en . Waar. Deze methoden volgen (zo dicht mogelijk) de C#LINQ-methodevorm. Zie LINQ gebruiken met de foutopsporingsprogrammaobjectenvoor meer informatie.

rasterweergave

Net als bij andere dx-opdrachten kunt u met de rechtermuisknop op een opdracht klikken nadat deze is uitgevoerd en op 'Weergeven als raster' klikken of '-g' toevoegen aan de opdracht om een rasterweergave van de resultaten te krijgen. U kunt vervolgens op een kolom klikken om te sorteren, bijvoorbeeld op InstancePath.

0: kd> dx -g @$devices().OrderBy(obj => obj.@"InstancePath")

Schermopname van de functie rasteruitvoer van foutopsporingsprogrammaobjecten met gesorteerde rijen.

Voorbeeld van procesthreads

Foutopsporingsprogrammaobjecten worden geprojecteerd in een naamruimte die is geroot op Foutopsporingsprogramma. Processen, modules, threads, stackframes en lokale variabelen zijn allemaal beschikbaar voor gebruik in een LINQ-query.

In dit voorbeeld van JavaScript ziet u hoe u het aantal threads voor de huidige sessiesprocessen kunt weergeven:

function __Processes()
{
    return host.currentSession.Processes.Select(p => ({Name: p.Name, ThreadCount: p.Threads.Count()}));
}

function initializeScript()
{
    return [new host.functionAlias(__Processes, "Processes")];
}

Hier ziet u de voorbeelduitvoer met de ! Functiealias processen.

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]

...

In dit voorbeeld wordt het top 5-proces met het grootste aantal threads weergegeven.

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]
    [...]

Zie ook

dx (Display Debugger Object Model Expression)

LINQ gebruiken met de foutopsporingsprogrammaobjecten

systeemeigen foutopsporingsprogrammaobjecten in NatVis-

Systeemeigen foutopsporingsprogrammaobjecten in JavaScript Extensions

Delen via