Megjegyzés
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhat bejelentkezni vagy módosítani a címtárat.
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhatja módosítani a címtárat.
A LINQ szintaxis használható a hibakereső objektumokkal az adatok keresésére és kezelésére. A LINQ szintaxis dx paranccsal való használata konzisztensebb élményt tesz lehetővé a hibakereső parancsokhoz képest. A kimenet és a beállítások konzisztensek, függetlenül attól, hogy melyik hibakereső objektumot vizsgálja. A LINQ-lekérdezésekkel olyan kérdéseket tehet fel, mint a "Mi az 5 legjobb folyamat, amely a legtöbb szálat futtatja?".
A hibakereső objektumok a "Debugger" helyen gyökerező névtérbe lesznek kivetítve. A LINQ-lekérdezésekben használható folyamatok, modulok, szálak, veremek, veremkeretek és helyi változók.
A LINQ elméletileg hasonló az adatbázisok lekérdezéséhez használt strukturált lekérdezési nyelvhez (SQL). Számos LINQ-metódussal kereshet, szűrhet és elemezhet hibakeresési adatokat. A LINQ C# metódus szintaxisa használatos. További információ a LINQ-ról és a LINQ C# szintaxisáról: A LINQ használatának első lépései a C#-ban
A hibakereső támogatásában használt LINQ a LINQ metódusszintaxisát használja, nem pedig a "lekérdezés szintaxisát". A LINQ (Language-Integrated Query) különbségeiről további információt talál.
A LINQ-parancsok, például a következők használhatók a hibakereső objektumokkal. Összes. Bármely. Gróf. Első. Szétlapít. GroupBy, . Utolsó. OrderBy, . OrderByDescending, . Válassza ki és. Hol. Ezek a metódusok a C# LINQ metódus űrlapot követik (a lehető legszorosabban).
Natív hibakereső objektumok
A natív hibakereső objektumok a hibakereső környezet különböző szerkezeteit és viselkedését jelölik. A hibakereső objektumok közé tartoznak például a következők.
- Ülés
- Szálak / szál
- Folyamatok / folyamat
- Stack Frames /Stack Frame
- Helyi változók
- Modulok / modul
- Hasznosság
- Állam
- Beállítások
A Hibakereső objektumokkal a NatVis használatával is dolgozhat. További információ: Natív hibakereső objektumok a NatVisben. További információ a hibakereső objektumok JavaScripttel való használatáról: JavaScript-bővítmények natív hibakereső objektumai. A C++ és az illesztőobjektumok használatával kapcsolatos információkért tekintse meg a Hibakereső adatmodell C++ áttekintését.
Dx parancs
Az itt bemutatott példák a dx parancsot használják, a dx paranccsal való munkával kapcsolatos további információkért lásd: dx (Display Debugger Object Model Expression).
LINQ-lekérdezés fejlesztése
A LINQ hibakereső objektumlekérdezés fejlesztésének egyik módja, ha a megjelenő DML-hivatkozásokkal vizsgálja meg az adatmodellt, hogy először keresse meg a lekérdezésben használni kívánt hibakereső objektumot.
Ebben a példában a kernel hibakeresési munkamenetében lévő folyamatok listáját és az egyes folyamatok szálainak számát szeretnénk megjeleníteni.
A feltárás megkezdéséhez a dx paranccsal megjeleníthetjük a legfelső szintű hibakereső objektumot.
0: kd> dx Debugger
Debugger
Sessions
Settings
State
Utility
A legfelső szintű témakörök kiválasztása után megállapítjuk, hogy a munkamenetek a legérdekesebbnek tűnnek, ezért a DML-hivatkozást választva kiderül, hogy az tartalmazza a folyamatokat.
0: kd> dx -r1 Debugger.Sessions[0]
Debugger.Sessions[0] : Remote KD: KdSrv:Server=@{<Local>},Trans=@{NET:Port=50005,Key=MyKey}
Processes
Id : 0
Attributes
Ezután tovább választunk az adott folyamat megtekintéséhez, és azt látjuk , hogy az adott folyamathoz társított szálak elérhetők. Amikor kiválasztjuk a szálakat az egyik folyamathoz, megjelenik az adott folyamathoz társított összes szál.
0: kd> dx -r1 Debugger.Sessions[0].Processes[1428].Threads
Debugger.Sessions[0].Processes[1428].Threads
[0x598] : <Unable to get stack trace> [Switch To]
[0x1220] : <Unable to get stack trace> [Switch To]
[0x6f8] : nt!KiSwapContext+0x76 (fffff806`4466a186) [Switch To]
[0x128c] : <Unable to get stack trace> [Switch To]
[0x27e4] : nt!KiSwapContext+0x76 (fffff806`4466a186) [Switch To]
Most már tudjuk, hogy a folyamathoz társított szálak számának megjelenítéséhez szükséges adatok elérhetők a hibakereső objektummodellben.
A LINQ-lekérdezés egy kicsit rövidebbé tétele érdekében a jelen témakör későbbi részében ismertetett rendszer által definiált változókkal jeleníthetjük meg az aktuális munkamenethez kapcsolódó folyamatokat.
0: kd> dx @$cursession.Processes
@$cursession.Processes
[0x0] : Idle [Switch To]
[0x4] : System [Switch To]
[0x90] : Registry [Switch To]
...
Ezután adjon hozzá egy SELECT utasítást. Először is megadhatja a Név mezőt.
0: kd> dx @$cursession.Processes.Select(p => p.Name)
@$cursession.Processes.Select(p => p.Name)
[0x0] : Idle
[0x4] : System
[0x90] : Registry
...
A forgatókönyvünkhöz a szálak számára is szükségünk van. Mivel két mező van, hozzon létre egy névtelen típust új, a C#névtelen típusszintaxisához hasonlóan, amelyet a felhasználó által definiált változók alább ismertetnek.
dx @$cursession.Processes.Select(p => new {Name = p.Name, Threads = p.Threads})
Ezzel a paranccsal a "dx" már nem nyomtatja ki a nevet, ezért adjon hozzá -r2 (két szint ismétlődése) a név és a szálak megjelenítéséhez.
dx -r2 @$cursession.Processes.Select(p => new {Name = p.Name, Threads = p.Threads})
@$cursession.Processes.Select(p => new {Name = p.Name, Threads = p.Threads})
[0x0]
Name : Idle
Threads
[0x4]
Name : System
Threads
[0x90]
Name : Registry
Threads
Ezen a ponton megjelenítjük a folyamat nevét és a szálak listáját. A ThreadCount megjelenítéséhez használja a . Count() metódus.
0: kd> dx -r2 @$cursession.Processes.Select(p => new {Name = p.Name, ThreadCount = p.Threads.Count()})
@$cursession.Processes.Select(p => new {Name = p.Name, ThreadCount = p.Threads.Count()})
[0x0]
Name : Idle
ThreadCount : 0x4
[0x4]
Name : System
ThreadCount : 0xe7
[0x90]
Name : Registry
ThreadCount : 0x4
...
Annak megtekintéséhez, hogy mely folyamatok rendelkeznek nagy számú szállal, rendezze a listát szálszám szerint az OrderByDescending használatával.
0: kd> dx -r2 @$cursession.Processes.Select(p => new {Name = p.Name, ThreadCount = p.Threads.Count()}).OrderByDescending(p => p.ThreadCount)
@$cursession.Processes.Select(p => new {Name = p.Name, ThreadCount = p.Threads.Count()}).OrderByDescending(p => p.ThreadCount)
[0x4]
Name : System
ThreadCount : 0xe7
[0xa38]
Name : svchost.exe
ThreadCount : 0x45
[0x884]
Name : MemCompression
ThreadCount : 0x3e
Formázott rácsban való megjelenítéshez módosítsa a "-r2" elemet "-g" formátumra. A rekurzió szintjét nem kell megadni, mert a rácsbeállítás megfelelően jeleníti meg az oszlopokat. Végül adja hozzá a ",d" formátumjelölőt a kimeneti decimális értékekhez.
0: kd> dx -g @$cursession.Processes.Select(p => new {Name = p.Name, ThreadCount = p.Threads.Count()}).OrderByDescending(p => p.ThreadCount),d
===========================================================================================
= = Name = ThreadCount =
===========================================================================================
= [4] - System - 231 =
= [2616] - svchost.exe - 69 =
= [2180] - MemCompression - 62 =
= [968] - explorer.exe - 61 =
Példák hibakereső objektumokra
Ez a példa a legtöbb szálat futtató első 5 folyamatot mutatja be:
0: kd> dx -r2 Debugger.Sessions.First().Processes.Select(p => new { Name = p.Name, ThreadCount = p.Threads.Count() }).OrderByDescending(p => p.ThreadCount),5
Debugger.Sessions.First().Processes.Select(p => new { Name = p.Name, ThreadCount = p.Threads.Count() }).OrderByDescending(p => p.ThreadCount),5
:
[0x4] :
Name : <Unknown Image>
ThreadCount : 0x73
[0x708] :
Name : explorer.exe
ThreadCount : 0x2d
[0x37c] :
Name : svchost.exe
ThreadCount : 0x2c
[0x6b0] :
Name : MsMpEng.exe
ThreadCount : 0x22
[0x57c] :
Name : svchost.exe
ThreadCount : 0x15
[...]
Ez a példa a plug and play eszközfa eszközeit mutatja be a fizikai eszközobjektum illesztőprogramjának neve szerint csoportosítva. Nem minden kimenet jelenik meg.
kd> dx -r2 Debugger.Sessions.First().Devices.DeviceTree.Flatten(n => n.Children).GroupBy(n => n.PhysicalDeviceObject->Driver->DriverName.ToDisplayString())
Debugger.Sessions.First().Devices.DeviceTree.Flatten(n => n.Children).GroupBy(n => n.PhysicalDeviceObject->Driver->DriverName.ToDisplayString())
:
["\"\\Driver\\PnpManager\""] :
[0x0] : HTREE\ROOT\0
[0x1] : ROOT\volmgr\0000 (volmgr)
[0x2] : ROOT\BasicDisplay\0000 (BasicDisplay)
[0x3] : ROOT\CompositeBus\0000 (CompositeBus)
[0x4] : ROOT\vdrvroot\0000 (vdrvroot)
...
Dx Parancsfül Automatikus Kiegészítés
A TAB billentyű automatikus kitöltése tisztában van a LINQ lekérdezési metódusokkal, és működni fog a lambda kifejezések paramétereivel.
Például írja be (vagy másolja és illessze be) a következő szöveget a hibakeresőbe. Ezután nyomja le többször a TAB billentyűt a lehetséges befejezések átjárásához.
dx -r2 Debugger.Sessions.First().Processes.Select(p => new {Name = p.Name, ThreadCount = p.Threads.Count() }).OrderByDescending(p => p.
Nyomja le annyiszor a TAB billentyűt, amíg meg nem jelenik a ".Name". Adjon hozzá egy záró zárójelet ")" és nyomja le az Enter billentyűt a parancs végrehajtásához.
kd> dx -r2 Debugger.Sessions.First().Processes.Select(p => new {Name = p.Name, ThreadCount = p.Threads.Count() }).OrderByDescending(p => p.Name)
Debugger.Sessions.First().Processes.Select(p => new {Name = p.Name, ThreadCount = p.Threads.Count() }).OrderByDescending(p => p.Name) :
[0x274] :
Name : winlogon.exe
ThreadCount : 0x4
[0x204] :
Name : wininit.exe
ThreadCount : 0x2
[0x6c4] :
Name : taskhostex.exe
ThreadCount : 0x8
...
Ez a példa egy kulcs-összehasonlító módszerrel végzett befejezést mutatja be. A helyettesítés sztring metódusokat mutat, mivel a kulcs egy sztring.
dx -r2 Debugger.Sessions.First().Processes.Select(p => new {Name = p.Name, ThreadCount = p.Threads.Count() }).OrderByDescending(p => p.Name, (a, b) => a.
Nyomja le többször a TAB billentyűt, amíg meg nem jelenik a ".Length". Adjon hozzá egy záró zárójelet ")" és nyomja le az Enter billentyűt a parancs végrehajtásához.
kd> dx -r2 Debugger.Sessions.First().Processes.Select(p => new {Name = p.Name, ThreadCount = p.Threads.Count() }).OrderByDescending(p => p.Name, (a, b) => a.Length)
Debugger.Sessions.First().Processes.Select(p => new {Name = p.Name, ThreadCount = p.Threads.Count() }).OrderByDescending(p => p.Name, (a, b) => a.Length) :
[0x544] :
Name : spoolsv.exe
ThreadCount : 0xc
[0x4d4] :
Name : svchost.exe
ThreadCount : 0xa
[0x438] :
Name : svchost.exe
Felhasználó által definiált változók
A felhasználó által definiált változó a változó nevének @$-val történő előtagolásával határozható meg. A felhasználó által definiált változók bármihez hozzárendelhetők, amit a dx felhasználhat, például lambdákhoz, LINQ-lekérdezések eredményeihez stb.
Létrehozhatja és beállíthatja egy ilyen felhasználói változó értékét.
kd> dx @$String1="Test String"
A definiált felhasználói változókat a Debugger.State.UserVariables vagy a @$vars használatával jelenítheti meg.
kd> dx Debugger.State.UserVariables
Debugger.State.UserVariables :
mySessionVar :
String1 : Test String
A változók a következővel távolíthatók el: Eltávolít.
kd> dx @$vars.Remove("String1")
Ez a példa bemutatja, hogyan definiálhat egy felhasználói változót a Debugger.Sesssions hivatkozásához.
kd> dx @$mySessionVar = Debugger.Sessions
A felhasználó által definiált változó az alábbi módon használható.
kd> dx -r2 @$mySessionVar
@$mySessionVar :
[0x0] : Remote KD: KdSrv:Server=@{<Local>},Trans=@{COM:Port=\\.\com3,Baud=115200,Timeout=4000}
Processes :
Devices
Rendszer által definiált változók
A következő rendszer által definiált változók bármely LINQ dx lekérdezésben használhatók.
@$cursession – Az aktuális munkamenet
@$curprocess – Az aktuális folyamat
@$curthread – Az aktuális szál
Ez a példa a rendszer által definiált változók használatát mutatja be.
kd> dx @$curprocess.Threads.Count()
@$curprocess.Threads.Count() : 0x4
kd> dx -r1 @$curprocess.Threads
@$curprocess.Threads :
[0x4adc] :
[0x1ee8] :
[0x51c8] :
[0x62d8] :
...
Felhasználó által definiált változók – Névtelen típusok
A dinamikus objektumok létrehozása a C# névtelen típusszintaxisával történik (új { ... }). A névtelen típusokról további információt a Névtelen típusok (C# programozási útmutató) című témakörben talál. Ez a példa egy névtelen típust hoz létre egész számmal és sztringértékkel.
kd> dx -r1 new { MyInt = 42, MyString = "Hello World" }
new { MyInt = 42, MyString = "Hello World" } :
MyInt : 42
MyString : Hello World
Függvényobjektumok (Lambda-kifejezések)
Az adatok lekérdezéséhez használt módszerek közül számos a felhasználó által biztosított függvény ismételt futtatásán alapul egy gyűjtemény objektumai között. A hibakeresőben lévő adatok lekérdezésének és módosításának támogatása érdekében a dx parancs támogatja a lambda kifejezéseket az egyenértékű C# szintaxissal. A lambda kifejezést az => operátor használata határozza meg az alábbiak szerint:
(argumentumok) => (eredmény)
Ha meg szeretné tudni, hogyan használja a LINQ-t a dx, próbálja ki ezt az egyszerű példát az 5 és a 7 együttes hozzáadásához.
kd> dx ((x, y) => (x + y))(5, 7)
A dx parancs visszakéri a lambda kifejezést, és megjeleníti a 12 eredményt.
((x, y) => (x + y))(5, 7) : 12
Ez a példa lambda kifejezés egyesíti a "Hello" és a "World" sztringeket.
kd> dx ((x, y) => (x + y))("Hello", "World")
((x, y) => (x + y))("Hello", "World") : HelloWorld
Támogatott LINQ szintaxis – Lekérdezési módszerek
Minden olyan objektum, amelyet a dx iterálhatóként határoz meg (legyen az natív tömb, egy natVis-et tárolóként leíró típus vagy hibakereső bővítményobjektum) linq (vagy LINQ-egyenértékű) metódusok sorozatával rendelkezik. Ezeket a lekérdezési módszereket az alábbiakban ismertetjük. A lekérdezési metódusok argumentumainak aláírása az összes lekérdezési metódus után megjelenik.
Szűrési módszerek
. Where ( PredicateMethod ): A bemeneti gyűjtemény minden objektumát tartalmazó új objektumgyűjteményt ad vissza, amelynek a predikátummetódusa igaz értéket adott vissza.
Vetítési módszerek
.Lapítás ( [KeyProjectorMethod] ): Egy konténerhalmazt vesz fel (egy fát), és összelapítja egyetlen konténerbe, amely tartalmazza a fa összes elemét. Ha a választható kulcsprojektor metódust adja meg, a fa kulcstárolónak minősül, amely maga is tároló, és ezeket a kulcsokat a vetítési módszer hívása határozza meg.
. Select ( KeyProjectorMethod ): Egy új objektumgyűjteményt ad vissza, amely a projektor metódus meghívásának eredményét tartalmazza a bemeneti gyűjtemény minden objektumán.
Csoportosítási módszerek
. GroupBy ( KeyProjectorMethod, [KeyComparatorMethod] ): Új gyűjteménygyűjteményt ad vissza a bemeneti gyűjtemény összes objektumának csoportosításával, amelynek kulcsát a kulcsprojektor metódus meghívása határozza meg. Választható összehasonlító módszer is megadható.
Illesztés (InnerCollection, Külső kulcsválasztó metódus, Belső kulcsválasztó metódus, Eredményválasztó metódus, [ComparatorMethod]): Két sorozatot illeszt össze a kulcsválasztó függvények alapján, és kinyeri az értékpárokat. Választható összehasonlító metódus is megadható.
Intersect (InnerCollection, [ComparatorMethod]):: A megadott metszetet adja vissza, ami azt jelenti, hogy a két gyűjtemény mindegyikében megjelennek elemek. Választható összehasonlító metódus is megadható.
Union (InnerCollection, [ComparatorMethod]):: A halmaz egyesítését adja vissza, ami a két gyűjtemény bármelyikében megjelenő egyedi elemeket jelenti. Választható összehasonlító metódus is megadható.
Adatkészlet-metódusok
Tartalmaz (Objektum, [ComparatorMethod]):: Meghatározza, hogy egy sorozat tartalmaz-e megadott elemet. Választható összehasonlító metódust is megadhat, amelyet minden alkalommal meghívunk, amikor az elemet összehasonlítjuk a sorozat egy bejegyzésével.
Distinct ([ComparatorMethod]):: Eltávolítja az ismétlődő értékeket egy gyűjteményből. Választható összehasonlító metódust is megadhat, amely meghívható minden alkalommal, amikor a gyűjtemény objektumait össze kell hasonlítani.
Kivéve (InnerCollection, [ComparatorMethod]):: A készletkülönbséget adja vissza, ami azt jelenti, hogy egy gyűjtemény azon elemei, amelyek nem jelennek meg egy második gyűjteményben. Választható összehasonlító metódus is megadható.
Összefűzés (InnerCollection): Összefűz két sorozatot egy sorozattá.
Rendezési módszerek
. OrderBy ( KeyProjectorMethod, [KeyComparatorMethod] ): A gyűjteményt növekvő sorrendbe rendezi a megadott kulcs szerint úgy, hogy meghívja a kulcsvetítési módszert a bemeneti gyűjtemény minden objektumán. Választható összehasonlító módszer is megadható.
. OrderByDescending ( KeyProjectorMethod, [KeyComparatorMethod] ): A gyűjteményt a megadott kulcs szerint csökkenő sorrendbe rendezi a bemeneti gyűjtemény minden objektumának kulcsvetítési metódusának meghívásával. Választható összehasonlító módszer is megadható.
Összesítő módszerek
Darabszám (): A gyűjtemény elemeinek számát visszaadó metódus.
Sum ([ProjectionMethod]):: Kiszámítja a gyűjtemény értékeinek összegét. Használhat egy kivetítő metódust az elemek átalakításához az összegzés előtt.
Metódusok kihagyása
Kihagyás (darabszám): Az elemeket egy adott pozícióig kihagyja egy sorozatban.
SkipWhile (PredicateMethod): Kihagyja a predikátumfüggvényen alapuló elemeket, amíg egy elem nem felel meg a feltételnek.
Metódusok használata
Take (Count): Elemeket vesz fel egy sorozaton belül, egy meghatározott pozícióig.
TakeWhile (PredicateMethod): Predikátumfüggvényen alapuló elemeket vesz fel, amíg egy elem nem felel meg a feltételnek.
Összehasonlító módszerek
SequenceEqual (InnerCollection, [ComparatorMethod]): Meghatározza, hogy két sorozat egyenlő-e az elemek párszintű összehasonlításával. Választható összehasonlító is megadható.
Hibakezelési módszerek
AllNonError (PredicateMethod): Azt adja vissza, hogy egy gyűjtemény összes nem hibaeleme megfelel-e egy adott feltételnek.
FirstNonError ([PredicateMethod]): A gyűjtemény első elemét adja vissza, amely nem hiba.
LastNonError ([PredicateMethod]):: Egy gyűjtemény utolsó elemét adja vissza, amely nem hiba.
Egyéb módszerek
. All (PredicateMethod ): Azt adja vissza, hogy a megadott predikátum metódus meghívásának eredménye igaz-e a bemeneti gyűjtemény minden elemére.
. Bármely ( PredicateMethod ): Azt adja vissza, hogy a megadott predikátum metódus meghívásának eredménye igaz-e a bemeneti gyűjtemény bármely elemére.
. First ( [PredicateMethod] ): A gyűjtemény első elemét adja vissza. Ha megadod az opcionális predikátumot, visszaadja a gyűjtemény első elemét, amelyre a predikátum igaz.
. Last ( [PredicateMethod] ): A gyűjtemény utolsó elemét adja vissza. Ha az opcionális predikátum átadásra kerül, a gyűjtemény utolsó elemét adja vissza, amelynek a predikátumra irányuló hívása igaz.
Min([KeyProjectorMethod]): A gyűjtemény minimális elemét adja vissza. Az egyes metódusok kivetítéséhez megadható egy választható projektormetódus, mielőtt összehasonlítanák másokkal.
Max([KeyProjectorMethod]):: A gyűjtemény maximális elemét adja vissza. Az egyes metódusok kivetítéséhez megadható egy választható projektormetódus, mielőtt összehasonlítanák másokkal.
Single([PredicateMethod]): A lista egyetlen elemét adja vissza (vagy hibát, ha a gyűjtemény több elemet tartalmaz). Ha egy predikátum meg van adva, az adott predikátumnak megfelelő egyetlen elemet adja vissza (ha egynél több elem felel meg, akkor a függvény hibát ad vissza).
Az argumentumok aláírása
| KeyProjectorMethod : ( obj => tetszőleges kulcs ) | A gyűjtemény egy objektumát veszi fel, és visszaad egy kulcsot az objektumból. |
| KeyComparatorMethod: ( (a; b) => egész számérték ) | Két kulcsot vesz, és összehasonlítja őket, az eredményt visszaadva: -1 ha ( a < b ) 0 ha ( a == b ) 1 ha ( a > b ) |
| PredikátumMethod: ( obj => logikai érték ) | A gyűjtemény egy objektumát veszi fel, és igaz vagy hamis értéket ad vissza attól függően, hogy az objektum megfelel-e bizonyos feltételeknek. |
Támogatott LINQ-szintaxis – Sztringkezelés
Minden sztringobjektumra a következő metódusok vannak kivetítve, így használhatók:
Releváns metódusok és tulajdonságok lekérdezése
. Contains ( OtherString ): Logikai értéket ad vissza, amely azt jelzi, hogy a bemeneti sztring tartalmazza-e az OtherString értéket.
. EndsWith ( OtherString ): Egy logikai értéket ad vissza, amely jelzi, hogy a bemeneti sztring az OtherStringgel végződik-e.
Hossz: A karakterlánc hosszát visszaadó tulajdonság.
. StartsWith ( OtherString ): Egy logikai értéket ad vissza, amely jelzi, hogy a bemeneti sztring az OtherStringgel kezdődik-e.
. Substring ( StartPos, [Length] ): A bemeneti sztringben lévő részsztringet adja vissza a megadott kezdő pozíciótól kezdve. Ha az opcionális hossz meg van adva, a visszaadott részszúrás a megadott hosszúságú lesz; ellenkező esetben – a sztring végére kerül.
Egyéb módszerek
. IndexOf ( OtherString ): Az OtherString első előfordulásának indexét adja vissza a bemeneti sztringen belül.
. LastIndexOf ( OtherString ): Az OtherString utolsó előfordulásának indexét adja vissza a bemeneti sztringen belül.
Formázási módszerek
. PadLeft ( TotalWidth ): Szükség szerint szóközöket ad hozzá a sztring bal oldalához, hogy a sztring teljes hosszát a megadott szélességre állítsa.
. PadRight ( TotalWidth ): Szükség szerint szóközöket ad hozzá a sztring jobb oldalához, hogy a sztring teljes hosszát a megadott szélességre állítsa.
. Remove ( StartPos, [Length] ): Eltávolítja a karaktereket a bemeneti sztringből a megadott kezdő pozíciótól kezdve. Ha az opcionális hosszparamétert adja meg, a program eltávolítja a karakterek számát; ellenkező esetben a sztring végéig minden karakter el lesz távolítva.
. Csere ( SearchString, ReplaceString ): A SearchString minden előfordulását lecseréli a bemeneti sztringen belül a megadott ReplaceStringre.
Sztringobjektum-vetítések
A közvetlenül sztringobjektumokra kivetített metódusok mellett minden olyan objektum, amely maga is rendelkezik sztringkonvertálással, a következő metódust vetíti rá, így a metódus használhatóvá válik:
. ToDisplayString ( ): Az objektum sztringátalakítását adja vissza. Ez a karakterlánc átalakítás, amely az objektum dx meghívásában jelenik meg. A ToDisplayString kimenetének formázásához megadhat egy formázási jelölőt. További információ: C++ formátumjelölői a Visual Studio hibakeresőjében
Az alábbi példák a formátumjelölők használatát szemléltetik.
kd> dx (10).ToDisplayString("d")
(10).ToDisplayString("d") : 10
kd> dx (10).ToDisplayString("x")
(10).ToDisplayString("x") : 0xa
kd> dx (10).ToDisplayString("o")
(10).ToDisplayString("o") : 012
kd> dx (10).ToDisplayString("b")
(10).ToDisplayString("b") : 0y1010
kd> dx ("some wchar string here").ToDisplayString("su")
("some wchar string here").ToDisplayString("su") : "some wchar string here"
kd> dx ("some wchar string here").ToDisplayString("sub")
("some wchar string here").ToDisplayString("sub") : some wchar string here
Példa a Plug and Play hibakeresési példájára
Ez a szakasz bemutatja, hogyan használhatók a LINQ-lekérdezésekkel használt beépített hibakereső objektumok a plug and play objektumok hibakeresésére.
Az összes eszköz megtekintése
Az összes eszköz megtekintéséhez használja az eszközfán az Elsimítás parancsot.
1: kd> dx @$cursession.Devices.DeviceTree.Flatten(n => n.Children)
@$cursession.Devices.DeviceTree.Flatten(n => n.Children)
[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)
[0x6] : ROOT\KDNIC\0000 (kdnic)
[0x7] : ROOT\UMBUS\0000 (umbus)
[0x8] : ROOT\ACPI_HAL\0000
...
Rácsos megjelenítési
A többi dx parancshoz hasonlóan, a parancsot végrehajtása után kijelölheti és nyomva tarthatja (vagy jobb gombbal kattinthat), majd választhatja a "Megjelenítés rácsként" lehetőséget, vagy hozzáadhatja a "-g" opciót a parancshoz, hogy az eredményeket rácsnézetben megtekinthesse.
# 0: kd> dx -g @$cursession.Devices.DeviceTree.Flatten(n => n.Children)
=====================================================================================================================================================================================================================================================================================================================
# = = (+) DeviceNodeObject = InstancePath = ServiceName = (+) PhysicalDeviceObject = State = (+) Resources = (+) Children =
=====================================================================================================================================================================================================================================================================================================================
= [0x0] : HTREE\ROOT\0 - {...} - HTREE\ROOT\0 - - 0xffffb6075614be40 : Device for "\Driver\PnpManager" - DeviceNodeStarted (776) - {...} - [object Object] =
= [0x1] : ROOT\volmgr\0000 (volmgr) - {...} - ROOT\volmgr\0000 - volmgr - 0xffffb607561fbe40 : Device for "\Driver\PnpManager" - DeviceNodeStarted (776) - {...} - [object Object] =
= [0x2] : ROOT\BasicDisplay\0000 (BasicDisplay) - {...} - ROOT\BasicDisplay\0000 - BasicDisplay - 0xffffb607560739b0 : Device for "\Driver\PnpManager" - DeviceNodeStarted (776) - {...} - [object Object] =
= [0x3] : ROOT\CompositeBus\0000 (CompositeBus) - {...} - ROOT\CompositeBus\0000 - CompositeBus - 0xffffb607561f9060 : Device for "\Driver\PnpManager" - DeviceNodeStarted (776) - {...} - [object Object] =
...
Eszközök megtekintése állapot szerint
A Where (Hol ) beállítással megadhat egy adott eszközállapotot.
dx @$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.State <operator> <state number>)
Ha például a DeviceNodeStarted állapotú eszközöket szeretné megtekinteni, használja ezt a parancsot.
1: kd> dx @$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.State == 776)
@$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.State == 776)
[0x0] : HTREE\ROOT\0
[0x1] : ROOT\volmgr\0000 (volmgr)
[0x2] : ROOT\BasicDisplay\0000 (BasicDisplay)
[0x3] : ROOT\CompositeBus\0000 (CompositeBus)
[0x4] : ROOT\vdrvroot\0000 (vdrvroot)
...
Nem elindított eszközök megtekintése
Ezzel a paranccsal megtekintheti azokat az eszközöket, amelyek nincsenek DeviceNodeStarted állapotban.
1: kd> dx @$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.State != 776)
@$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.State != 776)
[0x0] : ACPI\PNP0C01\1
[0x1] : ACPI\PNP0000\4&215d0f95&0
[0x2] : ACPI\PNP0200\4&215d0f95&0
[0x3] : ACPI\PNP0100\4&215d0f95&0
[0x4] : ACPI\PNP0800\4&215d0f95&0
[0x5] : ACPI\PNP0C04\4&215d0f95&0
[0x6] : ACPI\PNP0700\4&215d0f95&0 (fdc)
[0x7] : ACPI\PNP0C02\1
[0x8] : ACPI\PNP0C02\2
Eszközök megtekintése problémakód alapján
A DeviceNodeObject.Problem objektummal megtekintheti az adott problémakódokkal rendelkező eszközöket.
dx @$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.DeviceNodeObject.Problem <operator> <problemCode>)
Ha például nem nulla problémakóddal rendelkező eszközöket szeretne megtekinteni, használja ezt a parancsot. Ez hasonló információt nyújt a "!devnode 0 21"-hez.
1: kd> dx @$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.DeviceNodeObject.Problem != 0)
@$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.DeviceNodeObject.Problem != 0)
[0x0] : HTREE\ROOT\0
[0x1] : ACPI\PNP0700\4&215d0f95&0 (fdc)
Az összes eszköz megtekintése probléma nélkül
Ezzel a paranccsal problémamentesen tekintheti meg az összes eszközt
1: kd> dx @$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.DeviceNodeObject.Problem == 0)
@$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.DeviceNodeObject.Problem == 0)
[0x0] : ROOT\volmgr\0000 (volmgr)
[0x1] : ROOT\BasicDisplay\0000 (BasicDisplay)
[0x2] : ROOT\CompositeBus\0000 (CompositeBus)
[0x3] : ROOT\vdrvroot\0000 (vdrvroot)
...
Az összes, adott problémával rendelkező eszköz megtekintése
Ezzel a paranccsal megtekintheti az 0x16 problémás állapotú eszközöket.
1: kd> dx @$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.DeviceNodeObject.Problem == 0x16)
@$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.DeviceNodeObject.Problem == 0x16)
[0x0] : HTREE\ROOT\0
[0x1] : ACPI\PNP0700\4&215d0f95&0 (fdc)
Eszközök megtekintése függvényillesztő szerint
Ezzel a paranccsal funkciómeghajtó szerint tekintheti meg az eszközöket.
dx @$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.ServiceName <operator> <service name>)
Ha egy bizonyos függvényillesztőt (például atapi) használó eszközöket szeretne megtekinteni, használja ezt a parancsot.
1: kd> dx @$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.ServiceName == "atapi")
@$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => n.ServiceName == "atapi")
[0x0] : PCIIDE\IDEChannel\4&10bf2f88&0&0 (atapi)
[0x1] : PCIIDE\IDEChannel\4&10bf2f88&0&1 (atapi)
Rendszerindítási illesztőprogramok listájának megtekintése
A rendszerindítási illesztőprogramok listájának megtekintéséhez, amelyeket a winload betöltött, olyan környezetben kell lennie, ahol hozzáféréssel rendelkezik a LoaderBlockhoz, és elég korán, hogy a LoaderBlock még mindig elérhető legyen. Például az nt!IopInitializeBootDrivers. Ebben a környezetben egy töréspont állítható le.
1: kd> g
Breakpoint 0 hit
nt!IopInitializeBootDrivers:
8225c634 8bff mov edi,edi
Használja a ?? a rendszerindító illesztőprogram szerkezetének megjelenítésére szolgáló parancs.
1: kd> ?? LoaderBlock->BootDriverListHead
struct _LIST_ENTRY
[ 0x808c9960 - 0x808c8728 ]
+0x000 Flink : 0x808c9960 _LIST_ENTRY [ 0x808c93e8 - 0x808a2e18 ]
+0x004 Blink : 0x808c8728 _LIST_ENTRY [ 0x808a2e18 - 0x808c8de0 ]
Az adatok megtekintéséhez használja a Debugger.Utility.Collections.FromListEntry hibakereső objektumot az nt!_LIST_ENTRY struktúra kezdőcímével.
1: kd> dx Debugger.Utility.Collections.FromListEntry(*(nt!_LIST_ENTRY *)0x808c9960, "nt!_BOOT_DRIVER_LIST_ENTRY", "Link")
Debugger.Utility.Collections.FromListEntry(*(nt!_LIST_ENTRY *)0x808c9960, "nt!_BOOT_DRIVER_LIST_ENTRY", "Link")
[0x0] [Type: _BOOT_DRIVER_LIST_ENTRY]
[0x1] [Type: _BOOT_DRIVER_LIST_ENTRY]
[0x2] [Type: _BOOT_DRIVER_LIST_ENTRY]
[0x3] [Type: _BOOT_DRIVER_LIST_ENTRY]
[0x4] [Type: _BOOT_DRIVER_LIST_ENTRY]
[0x5] [Type: _BOOT_DRIVER_LIST_ENTRY]
...
Az adatok rácsnézetének létrehozásához használja a -g lehetőséget.
dx -r1 -g Debugger.Utility.Collections.FromListEntry(*(nt!_LIST_ENTRY *)0x808c9960, "nt!_BOOT_DRIVER_LIST_ENTRY", "Link")
Eszközök megtekintése képesség szerint
Eszközök megtekintése képesség szerint a DeviceNodeObject.CapabilityFlags objektummal.
dx -r1 @$cursession.Devices.DeviceTree.Flatten(n => n.Children).Where(n => (n.DeviceNodeObject.CapabilityFlags & <flag>) != 0)
Ez a táblázat a dx parancs használatát foglalja össze közös eszközképesség-jelzőkkel.
| Eltávolítható |
|
| UniqueID |
|
| SilentInstall |
|
| RawDeviceOk |
|
| SurpriseRemovalOK |
|
A CapabilityFlags szolgáltatással kapcsolatos további információkért lásd: DEVICE_CAPABILITIES.
Lásd még:
dx (Display Debugger Object Model Expression)
Natív hibakereső objektumok NatVis-
JavaScript-bővítmények natív hibakereső objektumai