← Back to ASP.NET Core Tutorial Home

Lesson 5: Running and Debugging Your App

Running and debugging are essential parts of software development. Writing code is only one side of programming; the other side is testing, observing behavior, and correcting errors. Visual Studio 2026 provides excellent debugging tools that make this much easier.

Running your ASP.NET Core application

There are two common ways to run your project in Visual Studio:

• F5 — Run with debugging
• Ctrl + F5 — Run without debugging

When you press F5, Visual Studio builds the project, starts the development web server, launches the browser, and attaches the debugger to the application.

What debugging means

Debugging is the process of examining how your program behaves while it is running. It allows you to pause execution, inspect variables, step through code line by line, and understand why something is not working as expected.

Using breakpoints

A breakpoint tells Visual Studio to pause execution at a specific line of code. To set a breakpoint, click in the left margin next to a line inside a controller action.

For example, you can place a breakpoint inside the Index() action of HomeController. When the browser loads the homepage, execution pauses there.

Inspecting variables

Once execution is paused, you can inspect values in several ways:

• Hover over a variable with the mouse
• Use the Locals window
• Use the Watch window
• Use the Autos window

These tools help you see what data is being processed at each point in the application.

Stepping through code

Visual Studio provides several stepping commands:

• F10 - Step Over: Execute the current line and move to the next line
• F11 - Step Into: Enter a method call to inspect it line by line
• Shift + F11 - Step Out: Exit the current method and return to the caller

These commands are especially useful when tracing logic inside controller actions or helper methods.

Watching the request flow

In an ASP.NET Core MVC application, debugging helps you understand the request flow:

• The browser requests a route
• Routing sends it to a controller action
• The controller prepares data
• A view is returned
• The browser displays the result

By placing breakpoints in your controller, you can observe this flow directly.

Common beginner errors

When learning ASP.NET Core, beginners often encounter these issues:

• Build errors caused by missing semicolons or syntax mistakes
• View not found errors due to wrong file names or folder placement
• Routing problems from incorrect action or controller names
• Port conflicts when another app is already using the same port
• Missing package references or broken dependencies

Useful debugging windows

Visual Studio 2026 includes several helpful windows:

• Error List — shows compile-time errors and warnings
• Output — shows runtime and build information
• Locals — shows nearby variable values
• Watch — tracks selected expressions
• Call Stack — shows which methods were called

Running without debugging

Sometimes you simply want to test the app quickly without attaching the debugger. In that case, use Ctrl + F5. This is useful when you want a faster launch or do not need step-by-step inspection.

Best practices for beginners

• Use breakpoints often while learning
• Read error messages carefully instead of ignoring them
• Test small changes one step at a time
• Keep your code organized and easy to trace
• Do not panic when the app fails to run; most errors have clear causes

Conclusion

Debugging is one of the most valuable skills you can develop as a programmer. With Visual Studio 2026, you have powerful tools to inspect your ASP.NET Core application, understand its behavior, and fix problems efficiently. As your projects become larger, these debugging skills will become even more important.