Använd rätt typ av brytpunkt

Artikel
01/20/2025

Den här artikeln visar hur du använder olika typer av brytpunkter i Visual Studio för att förbättra felsökningseffektiviteten. Den omfattar olika scenarier där brytpunkter kan användas, till exempel pausa kodkörning, loggningsinformation och spåra ändringar i variabeltillstånd. Artikeln beskriver hur du anger villkorsstyrda brytpunkter, spårningspunkter, data brytpunkter, beroende brytpunkter och tillfälliga brytpunkter. Den innehåller även detaljerade instruktioner om hur du ställer in funktionsbrytpunkter. Den här guiden är viktig för utvecklare som vill använda brytpunkter för effektiv felsökning i Visual Studio.

Om du inte är bekant med att använda brytpunkter i Visual Studio kan du läsa Komma igång med brytpunkter innan du går igenom den här artikeln.

För bästa möjliga upplevelse av den här dokumentationen väljer du önskat utvecklingsspråk eller körningsspråk i listan överst i artikeln.

Scenarier

I följande tabell visas vanliga felsökningsscenarier för brytpunkter och den rekommenderade brytpunktstypen för scenariot.

Scenarie	Beskrivning
Hur pausar jag körande kod för att inspektera en kodrad som kan innehålla ett fel?	Ange en brytpunkt. Mer information finns i Komma igång med brytpunkter.
Har min variabel ett oväntat värde? Eller vill jag inspektera min app när den når ett visst tillstånd?	Prova en villkorlig brytpunkt för att styra var och när en brytpunkt aktiveras med hjälp av villkorsstyrd logik. Högerklicka på en brytpunkt för att lägga till villkor. Ange villkoret som sant när variabeln är lika med det oväntade värdet. Mer information finns i Brytpunktsvillkor.
Hur loggar jag information till utdatafönstret under konfigurerbara villkor utan att ändra eller stoppa min kod?	Med spårningspunkter kan du logga information till utdatafönstret under konfigurerbara villkor utan att ändra eller stoppa koden. Mer information finns i Använda spårningspunkter i Visual Studio-felsökningsprogrammet.
Hur vet jag när värdet för min variabel ändras?	För C++ anger du en databrytpunkt. För appar som använder .NET Core 3 och senare kan du också ange en databrytpunkt. För endast C# och F# kan du annars spåra ett objekt-ID med en villkorlig brytpunkt.
Hur avbryter jag körningen endast om en annan brytpunkt nås?	Ange en beroende brytpunkt som endast avbryter körningen om en annan brytpunkt först träffas. För mer information, se beroendebrytpunkt.
Kan jag bara träffa en brytpunkt en gång?	Ange en tillfällig brytpunkt som gör att du bara kan bryta koden en gång. För mer information, se Tillfällig Brytpunkt.
Kan jag pausa kod i en loop vid en viss iteration?	Ange en beroende brytpunkt som endast bryter körningen om en annan brytpunkt först uppnås. Mer information finns i Träffräkning.
Kan jag pausa kod i början av en funktion när jag känner till funktionsnamnet men inte dess plats?	Du kan göra detta med en funktionsbrytpunkt. Mer information finns i Ange funktionsbrytpunkter.
Kan jag pausa kod i början av flera funktioner med samma namn?	När du har flera funktioner med samma namn (överlagrade funktioner eller funktioner i olika projekt) kan du använda en funktionsbrytpunkt.

Brytpunktsåtgärder och spårningspunkter

En spårpunkt är en brytpunkt som skriver ut ett meddelande till fönstret Output. En spårningspunkt kan fungera som en tillfällig spårningssats i ett programmeringsspråk och pausar inte körningen av kod. Du skapar en spårningspunkt genom att ange en särskild åtgärd i fönstret Brytpunktsinställningar. Detaljerade instruktioner finns i Använda spårningspunkter i Visual Studio-felsökningsprogrammet.

Brytpunktsvillkor

Du kan styra när och var en brytpunkt körs genom att ange villkor. Villkoret kan vara ett giltigt uttryck som felsökaren känner igen. (Mer information om giltiga uttryck finns i uttryck i felsökningsprogrammet.)

Ange ett brytpunktsvillkor:

Högerklicka på brytpunktssymbolen och välj Villkor (eller tryck på Alt + F9, C). Eller hovra över brytpunktssymbolen, välj ikonen Inställningar och välj sedan Villkor i fönstret Brytpunktsinställningar.

Du kan också högerklicka längst till vänster bredvid en kodrad och välja Infoga villkorsstyrd brytpunkt från snabbmenyn för att ange en ny villkorsstyrd brytpunkt.

Du kan också ange villkor i fönstret Brytpunkter genom att högerklicka på en brytpunkt och välja Inställningaroch sedan välja Villkor
I listrutan väljer du villkorsuttryck, Hit Counteller Filteroch anger värdet därefter.
Välj Stäng eller tryck på Ctrl+Retur för att stänga fönstret Brytpunktsinställningar. I fönstret Brytpunkter väljer du OK för att stänga dialogrutan.

Brytpunkter med villkor satta visas med en +-symbol i källkoden och Brytpunktsfönster.

Skapa ett villkorsuttryck

När du väljer villkorsuttryckkan du välja mellan två villkor: Är sant eller När det ändras. Välj Är sant att bryta när uttrycket är uppfyllt, eller När ändras för att bryta när värdet för uttrycket har ändrats.

I följande exempel slås brytpunkten bara när värdet för testInt är 4:

brytpunktsvillkoret är sant

I följande exempel slås brytpunkten bara när värdet för testInt ändras:

Brytpunkt När den ändras

brytpunkt När den ändras

Om du anger 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 slås. I båda fallen avbryter felsökningsprogrammet när det träffar den ogiltiga brytpunkten. Brytpunkten utesluts bara om villkoret är giltigt och utvärderas till false.

Notera

För fältet När det ändras anser felsökaren inte att den första utvärderingen av villkoret är en ändring, så den träffar inte brytpunkten vid den första utvärderingen.

Använd objekt-ID:n i villkorsuttryck (endast C# och F#)

Det finns tillfällen då du vill observera beteendet för ett visst objekt. Du kanske till exempel vill ta reda på varför ett objekt infogades i en samling mer än en gång. I C# och F# kan du skapa objekt-ID:n för specifika instanser av referenstyperoch använda dem i brytpunktsvillkor. Objekt-ID:t genereras av CLR-felsökningstjänsterna (Common Language Runtime) och associeras med objektet.

Så här skapar du ett objekt-ID:

Ange en brytpunkt i koden någonstans efter att objektet har skapats.
Starta felsökningen och när körningen pausar vid brytpunkten väljer du Felsöka>Windows>Locals (eller tryck på Ctrl + Alt + V, L) för att öppna fönstret Locals.

Leta upp den specifika objektinstansen i fönstret Locals, högerklicka på den och välj Gör objekt-ID.

Du bör se ett $ plus ett tal i fönstret Locals. Det här är objekt-ID:t.
Lägg till en ny brytpunkt vid den punkt som du vill undersöka. till exempel när objektet ska läggas till i samlingen. Högerklicka på brytpunkten och välj Villkor.
Använd objekt-ID:t i fältet villkorsuttryck. Om variabeln item till exempel är det objekt som ska läggas till i samlingen väljer du Är sant och skriver objekt == $<n>, där <n> är objekt-ID-numret.

Körningen bryts när objektet ska läggas till i samlingen.

Om du vill ta bort objekt-ID:t högerklickar du på variabeln i fönstret Locals och väljer Ta bort objekt-ID.

Notera

Objekt-ID:n skapar svaga referenser och förhindrar inte att objektet skräpsamlas. De är endast giltiga för den aktuella felsökningssessionen.

Ange ett villkor för antal träffar

Om du misstänker att en loop i koden börjar bete sig felaktigt efter ett visst antal iterationer kan du ange en brytpunkt för att stoppa körningen efter det antalet träffar, i stället för att behöva trycka på F5 upprepade gånger för att nå iterationen.

Under Villkor i fönstret Brytpunktsinställningar väljer du Hit Countoch anger sedan antalet iterationer. I följande exempel är brytpunkten inställd på att träffa varannan iteration.

Antal brytpunkter

Antal träffar på brytpunkt

Ange ett filtervillkor

Du kan begränsa en brytpunkt till att endast utlösas på angivna enheter eller i angivna processer och trådar.

Under Villkor i fönstret Brytpunktsinställningar väljer du Filtreraoch anger sedan ett eller flera av följande uttryck:

MachineName = "name"
ProcessId = värde
ProcessName = "name"
ThreadId = värde
ThreadName = "name"

Omslut strängvärden med dubbla citattecken. Du kan kombinera satser med & (AND), || (OR), ! (NOT) och parenteser.

Ange funktionsbrytningspunkter

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

Ange en funktionsbrytpunkt:

Välj Felsök>Ny brytpunkt>funktionsbrytpunkteller tryck på Ctrl + K, B.

Du kan också välja Ny>funktionsbrytpunkt i fönstret Brytpunkter.
I dialogrutan Ny funktionsbrytpunkt anger du funktionsnamnet i rutan Funktionsnamn.

Så här begränsar du funktionsspecifikationen:
- Använd det fullständigt kvalificerade funktionsnamnet.
  
  Exempel: Namespace1.ClassX.MethodA()
- Lägg till parametertyperna för en överbelastad funktion.
  
  Exempel: MethodA(int, string)
- Använd symbolen !för att ange modulen.
  
  Exempel: App1.dll!MethodA
- Använd kontextoperatorn i inbyggd C++.
  
  {function, , [module]} [+<line offset from start of method>]
  
  Exempel: {MethodA, , App1.dll}+2
I listrutan Language väljer du funktionens språk.
Välj OK.

Ange en funktionsbrytpunkt med hjälp av en minnesadress (endast inbyggd C++)

Du kan använda adressen till ett objekt för att ange en funktionsbrytpunkt för en metod som anropas av en specifik instans av en klass. Med ett adresserbart objekt av typen my_classkan du till exempel ange en funktionsbrytpunkt för den my_method metod som instansen anropar.

Ange en brytpunkt någonstans efter att instansen av klassen har instansierats.
Hitta adressen till instansen (till exempel 0xcccccccc).
Välj Felsök>Ny brytpunkt>funktionsbrytpunkteller tryck på Ctrl + K, B.
Lägg till följande i rutan funktionsnamn och välj C++ språk.
```
((my_class *) 0xcccccccc)->my_method
```

Ange data brytpunkter (.NET Core 3.x eller .NET 5+)

Dataavbrottspunkter avbryter körningen när en specifik objekts egenskap ändras.

Så här anger du en databrytpunkt:

I ett .NET Core- eller .NET 5+-projekt börjar du felsöka och väntar tills en brytpunkt har nåtts.
I fönstret Autos, Watcheller Locals högerklickar du på en egenskap och väljer Bryt när värdet ändras i snabbmenyn.

Data brytpunkter för .NET Core och .NET 5+ fungerar inte för:

Egenskaper som inte kan expanderas i knappbeskrivningsfönstret, Locals, Autos eller Watch
Statiska variabler
Klasser med attributet DebuggerTypeProxy
Fält inuti strukturer

För att få reda på det maximala antalet du kan ange, se maskinvarubegränsningar för databrytpunkt.

Ange data brytpunkter (endast inbyggd C++)

Databrytpunkter gör att körningen avbryts när ett värde som lagras på en angiven minnesadress ändras. Om värdet läss men inte ändras bryts inte körningen.

Så här ställer du in en databrytpunkt:

I ett C++-projekt börjar du felsöka och väntar tills en brytpunkt har nåtts. På menyn Felsöka väljer du Ny brytpunkt>databrytpunkt.

Du kan också välja Ny>databrytpunkt i fönstret Brytpunkter eller högerklicka på ett objekt i fönstret Autos, Watch, eller Locals och välja Bryt när värdet ändras i snabbmenyn.
I rutan Adress anger du en minnesadress eller ett uttryck som resulterar i en minnesadress. Skriv till exempel &avar för att bryta när innehållet i variabeln avar ändras.
I listrutan byteantal väljer du det antal byte som du vill att felsökaren ska titta på. Om du till exempel väljer 4tittar felsökaren på de fyra byte som börjar vid &avar och bryter om något av dessa byte ändrar värde.

Data brytpunkter fungerar inte under följande villkor:

En process som inte felsöks skriver till en minnesadress.
Minnesplatsen delas mellan två eller flera processer.
Minnesplatsen uppdateras i kerneln. Om minnet till exempel skickas till funktionen 32-bitars Windows ReadFile uppdateras minnet från kernelläget, så felsökningsprogrammet bryts inte vid uppdateringen.
Där klockuttrycket är större än 4 byte på 32-bitars maskinvara och 8 byte på 64-bitars maskinvara. Det här är en begränsning i x86-arkitekturen.

Not

Data brytpunkter beror på specifika minnesadresser. Adressen för en variabel ändras från en felsökningssession till nästa, så data brytpunkter inaktiveras automatiskt i slutet av varje felsökningssession.
Om du anger en data brytpunkt på en lokal variabel förblir brytpunkten aktiverad när funktionen slutar, men minnesadressen är inte längre tillämplig, så brytpunktens beteende är oförutsägbart. Om du anger en data brytpunkt för en lokal variabel bör du ta bort eller inaktivera brytpunkten innan funktionen slutar.

Databrytpunkters maskinvarubegränsningar

Windows-kerneln och den underliggande maskinvaran har följande gränser när du anger data brytpunkter. Gränsen avser det maximala antalet data brytpunkter som du kan ange.

Processorarkitektur	Gräns för databrytpunkt
x64 och x86	4
ARM64	2
ARM	1

Ange en beroende brytpunkt

Beroende brytpunkter avbryter endast körningen om en annan brytpunkt först träffas. I ett komplext scenario som att felsöka ett program med flera trådar kan du konfigurera ytterligare brytpunkter efter att en annan brytpunkt först har träffats. Detta kan göra felsökning av kod i vanliga vägar, som en spel-loop eller ett verktygs-API, mycket enklare eftersom en brytpunkt i dessa funktioner kan konfigureras att endast utlösas om funktionen anropas från en viss del av ditt program.

Ange en beroende brytpunkt:

Hovra över brytpunktssymbolen, välj ikonen Inställningar och välj sedan Aktivera endast när följande brytpunkt träffas i fönstret Brytpunktsinställningar.
I listrutan väljer du den nödvändiga brytpunkt som du vill att den aktuella brytpunkten ska vara beroende av.

Välj Stäng eller tryck på Ctrl+Retur för att stänga fönstret Brytpunktsinställningar. I fönstret Brytpunkter väljer du OK för att stänga dialogrutan. beroende brytpunkt

Du kan också använda högerklicksmenyn för att ange den beroende brytpunkten.

Högerklicka längst till vänster bredvid en kodrad och välj Infoga beroende brytpunkt från snabbmenyn.

Beroende brytpunkter fungerar inte om det bara finns en enda brytpunkt i ditt program.
Beroendebrytpunkter konverteras till normala radbrytpunkter om förutsättningsbrytpunkt tas bort.

Ange en tillfällig brytpunkt

Med den här brytpunkten kan du bara bryta koden en gång. Vid felsökning pausar Visual Studio-felsökningsprogrammet bara det körande programmet en gång för den här brytpunkten och tar sedan bort det omedelbart efter att det nåtts.

Ange en tillfällig brytpunkt:

Hovra över brytpunktssymbolen, välj ikonen Inställningar och välj sedan Ta bort brytpunkt när du har träffat i fönstret Brytpunktsinställningar.
Välj Stäng eller tryck på Ctrl+Retur för att stänga fönstret Brytpunktsinställningar. I fönstret Brytpunkter väljer du OK för att stänga dialogrutan.

Du kan också använda snabbmenyn för högerklick för att ange den tillfälliga brytpunkten.

Högerklicka längst till vänster bredvid en kodrad och välj Infoga tillfällig brytpunkt från snabbmenyn.

Eller använd bara genvägen F9 + Skift + Alt, T och ange den tillfälliga brytpunkten på önskad rad.

Dela via

Använd rätt typ av brytpunkt

Scenarier

Brytpunktsåtgärder och spårningspunkter