använd brytpunkter i felsökaren för Visual Studio

• 06/30/2020
• 12 minuter att läsa
• • M
  • g
  • j
  • v
  • g
  • +8

brytpunkter är en av de viktigaste felsökningsteknikerna i utvecklarens verktygslåda. Du ställer in brytpunkter var du vill pausa felsökningsutförande. Du kanske till exempel vill se tillståndet för kodvariabler eller titta på samtalsstacken vid en viss Brytpunkt. Om du försöker lösa en varning eller ett problem när du använder brytpunkter läser du felsöka brytpunkter i Visual Studio debugger.

Ställ in brytpunkter i källkoden

du kan ställa in en brytpunkt på valfri rad körbar kod. I följande C # – kod kan du till exempel ställa in en brytpunkt på kodraden med variabeltilldelningen (int testInt = 1), for – slingan eller någon kod i for – slingan. Du kan inte ange en brytpunkt för metodsignaturer, deklarationer för ett namnområde eller en klass eller variabeldeklarationer om det inte finns någon tilldelning och ingen getter/setter.

för att ställa in en brytpunkt i källkoden, Klicka längst till vänster bredvid en kodrad. Du kan också välja raden och trycka på F9, välj Debug > växla Brytpunkt eller högerklicka och välj Brytpunkt > infoga Brytpunkt. Brytpunkten visas som en röd punkt i den vänstra marginalen.

för de flesta språk, inklusive C#, Brytpunkt och nuvarande exekveringslinjer markeras automatiskt. För C++ – kod kan du aktivera markering av Brytpunkt och aktuella rader genom att välja verktyg (eller felsöka) > alternativ > felsökning > markera hela källraden för brytpunkter och aktuellt uttalande (endast C++).

när du felsöker avbryts körningen vid brytpunkten innan koden på den raden körs. Brytpunktssymbolen visar en gul pil.

vid brytpunkten i följande exempel är värdet testInt fortfarande 1. Så värdet har inte ändrats sedan variabeln initialiserades (satt till ett värde av 1) eftersom uttalandet i gult ännu inte har exekverats.

när felsökaren stannar vid brytpunkten kan du titta på appens aktuella tillstånd, inklusive variabla värden och samtalsstacken.

här är några allmänna instruktioner för att arbeta med brytpunkter.

• brytpunkten är en växel. Du kan klicka på den, trycka på F9 eller använda Debug > växla Brytpunkt för att radera eller sätta i den igen.

• för att inaktivera en brytpunkt utan att ta bort den, håll muspekaren över eller högerklicka på den och välj Inaktivera Brytpunkt. Inaktiverade brytpunkter visas som tomma punkter i den vänstra marginalen eller i Brytpunktsfönstret. För att återaktivera en brytpunkt, håll muspekaren över eller högerklicka på den och välj Aktivera Brytpunkt.

• Ställ in Villkor och åtgärder, Lägg till och Redigera etiketter eller exportera en brytpunkt genom att högerklicka på den och välja lämpligt kommando eller sväva över det och välja inställningsikonen.

Brytpunktsåtgärder och spårpunkter

en spårpunkt är en brytpunkt som skriver ut ett meddelande till utdatafönstret. En tracepoint kan fungera som ett tillfälligt spårningsuttalande i programmeringsspråket och pausar inte exekveringen av kod. Du skapar en tracepoint genom att ställa in en särskild åtgärd i fönstret Brytpunktsinställningar. För detaljerade instruktioner, se Använd tracepoints i Visual Studio debugger.

Brytpunktsvillkor

du kan styra när och var en brytpunkt körs genom att ställa in villkor. Villkoret kan vara vilket giltigt uttryck som felsökaren känner igen. Mer information om giltiga uttryck finns i uttryck i felsökaren.

för att ställa in ett brytpunktsvillkor:

1. högerklicka på brytpunktssymbolen och välj villkor (eller tryck på Alt + F9, C). Eller håll muspekaren över brytpunktssymbolen, välj ikonen Inställningar och välj sedan villkor i fönstret Brytpunktsinställningar.

   du kan också ställa in villkor i fönstret brytpunkter genom att högerklicka på en brytpunkt och välja Inställningar och sedan välja villkor.

   

2. i rullgardinsmenyn väljer du villkorat uttryck, Träffräkning eller Filter och ställer in värdet i enlighet därmed.

3. välj Stäng eller tryck på Ctrl + Enter för att stänga fönstret Brytpunktsinställningar. Eller i fönstret brytpunkter väljer du OK för att stänga dialogrutan.

brytpunkter med villkor som visas med en + symbol i källkoden och brytpunkter fönster.

skapa ett villkorligt uttryck

när du väljer villkorligt uttryck kan du välja mellan två villkor: är sant eller när det ändras. Välj är sant att bryta när uttrycket är nöjd, eller när ändras för att bryta när värdet av uttrycket har ändrats.

i följande exempel träffas brytpunkten endast när värdet på testInt är 4:

i följande exempel träffas brytpunkten endast när värdet på testInt ändras:

om du ställer in ett brytpunktsvillkor med ogiltig syntax visas ett varningsmeddelande. Om du anger ett brytpunktsvillkor med giltig syntax men ogiltig semantik visas ett varningsmeddelande första gången brytpunkten träffas. I båda fallen bryts felsökaren när den träffar den ogiltiga brytpunkten. Brytpunkten hoppas över endast om villkoret är giltigt och utvärderas till false.

använd Objekt-ID i villkorliga uttryck (endast C# och F#)

det finns tillfällen när du vill observera beteendet hos ett specifikt objekt. Du kanske till exempel vill ta reda på varför ett objekt har infogats i en samling mer än en gång. I C # och F# kan du skapa objekt-ID för specifika instanser av referenstyper och använda dem i brytpunktsförhållanden. Object ID genereras av common language runtime (CLR) felsökningstjänster och associeras med objektet.

för att skapa ett objekt-ID:

1. Ställ in en brytpunkt i koden någon plats efter att objektet har skapats.

2. starta felsökning, och när körningen pausar vid brytpunkten väljer du Debug > Windows > Locals (eller tryck Ctrl + Alt + V, L) för att öppna Locals-fönstret.

   hitta den specifika objektinstansen i Lokalfönstret, högerklicka på den och välj Gör Objekt-ID.

   du bör se ett $ plus ett nummer i Lokalfönstret. Detta är objektets ID.

3. Lägg till en ny Brytpunkt vid den punkt du vill undersöka; till exempel när objektet ska läggas till i samlingen. Högerklicka på brytpunkten och välj villkor.

4. använd Objekt-ID i fältet villkorat uttryck. Om variabeln item till exempel är objektet som ska läggas till i samlingen, välj är sant och skriv item == $<n>, där <n> är objektets ID-nummer.

   exekvering kommer att bryta vid den punkt då objektet ska läggas till i samlingen.

   om du vill ta bort objekts-ID högerklickar du på variabeln i Lokalfönstret och väljer Ta bort objekts-ID.

ange ett träffräkningsvillkor

om du misstänker att en slinga i din kod börjar fungera felaktigt efter ett visst antal iterationer kan du ställa in en brytpunkt för att stoppa körningen efter det antalet träffar, snarare än att behöva trycka upprepade gånger på F5 för att nå den iterationen.

under villkor i fönstret Brytpunktsinställningar väljer du Träffräkning och anger sedan antalet iterationer. I följande exempel är brytpunkten inställd på att slå på alla andra iterationer:

Ställ in ett filtervillkor

du kan begränsa en brytpunkt till brand endast på angivna enheter eller i angivna processer och trådar.

under villkor i fönstret Brytpunktsinställningar väljer du Filter och anger sedan ett eller flera av följande uttryck:

• MachineName = “namn”
• ProcessId = värde
• ProcessName = “namn”
• ThreadId = värde
• ThreadName = “namn”

bifoga strängvärden i dubbla citat. Du kan kombinera satser med & (och), || (eller), ! (inte) och parenteser.

Ställ in funktionsbrytpunkter

du kan bryta körningen när en funktion anropas. Detta är till exempel användbart när du känner till funktionsnamnet men inte dess plats. Det är också användbart om du har funktioner med samma namn och du vill bryta på dem alla (till exempel överbelastade funktioner eller funktioner i olika projekt).

för att ställa in en funktionsbrytpunkt:

1. Välj Debug > Ny Brytpunkt > Funktionsbrytpunkt, eller tryck på Ctrl + K, B.

   du kan också välja ny > Funktionsbrytpunkt i fönstret brytpunkter.

2. i dialogrutan Ny Funktionsbrytpunkt anger du funktionsnamnet i rutan funktionsnamn.

   för att begränsa funktionsspecifikationen:

   • använd det fullständiga funktionsnamnet.

     exempel: Namespace1.ClassX.MethodA()

   • Lägg till parametertyperna för en överbelastad funktion.

     exempel: MethodA(int, string)

   • använd ‘!’symbol för att ange modulen.

     exempel: App1.dll!MethodA

   • använd kontextoperatören i native C++.

     {function, , }

     exempel: {MethodA, , App1.dll}+2

3. i rullgardinsmenyn språk väljer du språk för funktionen.

4. välj OK.

ange en funktionsbrytpunkt med en minnesadress (endast C++)

du kan använda adressen till ett objekt för att ställa in en funktionsbrytpunkt på en metod som anropas av en specifik instans av en klass. Till exempel, givet ett adresserbart objekt av typen my_class, kan du ställa in en funktionsbrytpunkt på my_method – metoden som instansen anropar.

1. Ställ in en brytpunkt någonstans efter instansen av klassen instansieras.

2. hitta adressen till instansen (till exempel 0xcccccccc).

3. Välj Debug > Ny Brytpunkt > Funktionsbrytpunkt, eller tryck på Ctrl + K, B.

4. Lägg till följande i rutan funktionsnamn och välj C++ språk.

   ((my_class *) 0xcccccccc)->my_method

Ställ in databrytpunkter (endast C++)

databrytpunkter bryter körningen när ett värde som lagras vid en viss minnesadress ändras. Om värdet läses men inte ändras bryts inte körningen.

för att ställa in en databrytpunkt:

1. i ett C++ – projekt startar du felsökning och väntar tills en brytpunkt nås. På felsökningsmenyn väljer du ny Brytpunkt > Databrytpunkt.

   du kan också välja ny > Databrytpunkt i Brytpunktsfönstret eller högerklicka på ett objekt i fönstret Autos, Watch eller Locals och välja Bryt när värdet ändras i snabbmenyn.

2. i rutan adress skriver du en minnesadress eller ett uttryck som utvärderas till en minnesadress. Skriv till exempel &avar för att bryta när innehållet i variabeln avar ändras.

3. i rullgardinsmenyn Byte Count väljer du antalet byte som du vill att felsökaren ska titta på. Om du till exempel väljer 4 kommer felsökaren att titta på de fyra byte som börjar vid &avar och bryta om någon av dessa byte ändrar värde.

databrytpunkter fungerar inte under följande förhållanden:

• en process som inte felsöks skriver till minnesplatsen.
• minnesplatsen delas mellan två eller flera processer.
• minnesplatsen uppdateras i kärnan. Om minnet till exempel skickas till 32-bitars windows ReadFile – funktionen uppdateras minnet från kärnläget, så felsökaren går inte sönder vid uppdateringen.
• där klockuttrycket är större än 4 byte på 32-bitars hårdvara och 8 byte på 64-bitars hårdvara. Detta är en begränsning av x86-arkitekturen.

hantera brytpunkter i Brytpunktsfönstret

du kan använda Brytpunktsfönstret för att se och hantera alla brytpunkter i din lösning. Denna centraliserade plats är särskilt användbar i en stor lösning eller för komplexa felsökningsscenarier där brytpunkter är kritiska.

i fönstret brytpunkter kan du söka, sortera, filtrera, aktivera/inaktivera eller ta bort brytpunkter. Du kan också ställa in Villkor och åtgärder, eller lägga till en ny funktion eller databrytpunkt.

om du vill öppna Brytpunktsfönstret väljer du Debug > Windows > brytpunkter eller trycker på Ctrl+Alt+B.

om du vill välja de kolumner som ska visas i Brytpunktsfönstret väljer du visa kolumner. Välj en kolumnrubrik för att sortera brytpunktslistan efter den kolumnen.

Brytpunktetiketter

du kan använda etiketter för att sortera och filtrera listan över brytpunkter i fönstret brytpunkter.

1. om du vill lägga till en etikett i en brytpunkt högerklickar du på brytpunkten i källkoden eller fönstret brytpunkter och väljer sedan Redigera etiketter. Lägg till en ny etikett eller välj en befintlig och välj sedan OK.
2. Sortera brytpunktslistan i Brytpunktsfönstret genom att välja etiketter, villkor eller andra kolumnrubriker. Du kan välja vilka kolumner som ska visas genom att välja Visa kolumner i verktygsfältet.

exportera och importera brytpunkter

för att spara eller dela tillståndet och platsen för dina brytpunkter kan du exportera eller importera dem.

• om du vill exportera en enskild Brytpunkt till en XML-fil högerklickar du på brytpunkten i fönstret källkod eller brytpunkter och väljer Exportera eller exportera markerad. Välj en exportplats och välj sedan spara. Standardplatsen är lösningsmappen.
• om du vill exportera flera brytpunkter markerar du rutorna bredvid brytpunkterna i fönstret brytpunkter eller anger sökkriterier i sökfältet. Välj Exportera alla brytpunkter som matchar den aktuella sökkriterieikonen och spara filen.
• om du vill exportera alla brytpunkter avmarkerar du alla rutor och lämnar sökfältet tomt. Välj Exportera alla brytpunkter som matchar den aktuella sökkriterieikonen och spara filen.
• om du vill importera brytpunkter väljer du importera brytpunkter från en filikon i fönstret brytpunkter, navigerar till XML-filens plats och väljer Öppna.

Ställ in brytpunkter från debugger windows

du kan också ställa in brytpunkter från Call Stack och demontering debugger windows.

Ställ in en brytpunkt i fönstret Anropsstack

för att bryta på den instruktion eller linje som en anropande funktion återgår till, kan du ställa in en brytpunkt i fönstret Anropsstack.

för att ställa in en brytpunkt i fönstret Call Stack:

1. för att öppna fönstret Call Stack måste du pausas under felsökning. Välj Debug > Windows > Call Stack, eller tryck Ctrl + Alt + C.

2. högerklicka på anropsfunktionen i fönstret Anropsstack och välj Brytpunkt > infoga Brytpunkt eller tryck på F9.

   en brytpunktssymbol visas bredvid funktionsanropets namn i den vänstra marginalen i anropsstacken.

brytpunkten för anropsstacken visas i Brytpunktsfönstret som en adress, med en minnesplats som motsvarar nästa körbara instruktion i funktionen.

felsökaren bryts vid instruktionen.

för mer information om samtalsstacken, se Så här: använd fönstret Samtalsstack.

för att visuellt spåra brytpunkter under kodkörning, se Kartmetoder på samtalsstacken medan felsökning.

Ställ in en brytpunkt i Demonteringsfönstret

1. för att öppna Demonteringsfönstret måste du pausas under felsökning. Välj Debug > Windows > demontering, eller tryck Ctrl + Alt + D.

2. i Demonteringsfönstret klickar du på den vänstra marginalen för den instruktion du vill bryta på. Du kan också välja den och trycka på F9, eller högerklicka och välj Brytpunkt > infoga Brytpunkt.

Se även

• vad är felsökning?
• Skriv bättre C # – kod med Visual Studio
• först titta på Felsökning
• felsöka brytpunkter i Visual Studio debugger