What is a breakpoint, and how do you step through .NET code with Step Into, Step Over and Step Out?

1. What happens when you press F5

 F5 (Start Debugging)
   |
   v
 IDE builds the project (Debug configuration by default)
   |   compiler writes MyApp.dll + MyApp.pdb (portable PDB)
   v
 debugger launches the process (or attaches to an existing one)
   |   and connects through the runtime's debugging interface
   v
 runtime reports every module (DLL) it loads
   |   debugger looks for a matching PDB for each one
   v
 pending breakpoints in that module are BOUND
   (solid red circle)  or stay UNBOUND (hollow circle)

A breakpoint you set before the code has loaded is "pending". It binds as soon as the runtime loads the module and the debugger finds matching symbols.

2. How a breakpoint becomes a pause

 source line 42
     |  PDB sequence point
     v
 IL offset 0x1A in method OrderMath.Total
     |  JIT compiles the method to native code
     v
 native address 0x7FF6...
     |  debugger asks the runtime to patch it
     v
 breakpoint instruction (int 3 on x64, brk on Arm64)
     |  the CPU traps when it reaches it
     v
 runtime suspends ALL managed threads --> notifies debugger
     --> IDE highlights line 42 and shows locals

The PDB is the link between your source and the compiled code. It contains:

3. The stepping commands in detail

Rider has the same commands. With its Visual Studio keymap the keys match the table.

Stepping is implemented with temporary breakpoints and single-stepping. That is why Step Over a call that waits on I/O looks like a hang: the call really is still running, and the debugger is waiting for it to return.

4. Stepping through async code

An await splits a method into a state machine. The code after the await may run on a different thread.

 async Task<decimal> TotalAsync()
 {
     var rates = await _rates.GetAsync();   <-- Step Over here
     return Sum(rates);                     <-- debugger stops here when
 }                                              the await completes,
                                                maybe on another thread

Modern debuggers are async-aware: Step Over on an await line waits for that specific continuation and stops on the next line of the same logical method, even if another thread runs it. Use the Tasks and Parallel Stacks windows in Visual Studio to see where async work is waiting.

5. Debug versus Release when debugging

Debug locally for logic bugs. Switch to Release only when a bug only happens there, and expect a rougher stepping experience.

6. Why a breakpoint is hollow

Hover over the hollow circle for the reason, then work through this table:

7. Debugging outside Visual Studio

8. Performance and safety

• While stopped, every managed thread is paused, so timers, HTTP timeouts, database command timeouts and health checks fire late or fail after you continue. Don't chase those failures as if they were the bug.
• Never pause a shared or production process interactively. It stops serving everyone. Use logs, traces and dumps there.
• Debugger.Break() and Debugger.Launch() left in code will try to start a debugger on a server or stop a test run. Remove them before committing, or guard them with #if DEBUG.

9. .NET 11 awareness

The stepping model is stable. Debugger improvements arrive through Visual Studio, Rider and the C# extension releases rather than the runtime, so check their release notes alongside .NET 11.

10. Try it yourself

1. Create dotnet new console -n StepDemo and paste the code example.
2. Set a breakpoint on decimal total = OrderMath.Total(orders); and press F5.
3. Press F11 to step into Total, then F10 through the loop, and watch i in the Locals window.
4. Press Shift+F11 to return to the caller and see the wrong total.
5. Fix the loop, use Set Next Statement to move back to the call, and step again.
6. Switch the configuration to Release, debug again, and compare how stepping and Locals behave.
7. Open Debug > Windows > Modules and find StepDemo.dll and its symbol status.

A small program with a bug to find by stepping:

var orders = new List<Order>
{
    new("A-100", 120.50m),
    new("A-101", 89.95m),
    new("A-102", 230.00m),
};

decimal total = OrderMath.Total(orders);
Console.WriteLine($"Total: {total:0.00}");

public sealed record Order(string Number, decimal Amount);

public static class OrderMath
{
    public static decimal Total(IReadOnlyList<Order> orders)
    {
        decimal total = 0;
        for (var i = 1; i < orders.Count; i++) // bug: the first order is skipped
        {
            total += orders[i].Amount;
        }

        return total;
    }
}

Run it under the debugger from the CLI-built output in VS Code with a minimal launch.json entry:

{
  "name": "StepDemo",
  "type": "coreclr",
  "request": "launch",
  "program": "${workspaceFolder}/bin/Debug/net10.0/StepDemo.dll",
  "cwd": "${workspaceFolder}"
}