C# Debugging in Visual Studio 2019 Tutorial — Part 1
Unfortunately, writing code goes hand in hand with creating bugs. We all cause bugs, it’s one of the inevitable facts of life. This process of solving those bugs is called Debugging.
Debugging comes in many forms: Stepping through the code with a debugger, investigating logs, unit testing, profiling, and analyzing dumps. As .NET developers, our main form of debugging is interactive debugging, with Visual Studio. Interactive debugging means attaching to a running process with a debugger, and investigating the program’s execution and state.
Visual Studio (VS) is not the only debugger at our disposal (we also have WinDbg , Rider , and dnSpy ). But, Visual Studio is the most widely used and the focus of this article. VS might seem easy to start with, but it has a great many features that are crucial to effective debugging. Mastering Visual Studio debugging will decrease debugging time and turn you into a more effective developer.
This article takes you through the slippery ropes of VS debugging from a beginner to an expert debugger. We are not going to cover the more specific tips and tricks of .NET debugging (There are other articles for that). We are going to build the fundamentals of debugging – A foundation of knowledge for you to become a master of debugging in Visual Studio.
This first part is for beginners to debugging, starting from the very basics.
1. Attaching the debugger
Debugging in Visual Studio occurs automatically when you run from Visual Studio with F5 or select Debug | Start Debugging.
When doing, so Visual Studio attached itself as a debugger to the program. Alternatively, you can attach to a running process with Debug | Attach to Process… (Ctrl+Alt+P).
2. Debugger Break Mode
The debugged process has to be in “Break Mode” for debugging. That means the program is currently paused on a specific line of code. More accurately, all the running threads are paused on a specific line of code.
You can get to break mode with Debug | Break All menu item (Ctrl+Alt+Break) or by placing breakpoints.
We’re usually going to use breakpoints because in most debugging scenarios we will want to debug when the program reaches a certain line of code.
You can place breakpoints by clicking on the margin, pressing F9, or Debug | Toggle Breakpoint. Once set, when your program reaches that line of code, Visual Studio’s debugger will stop execution and enter “Break Mode”:
In break mode, the yellow line represents the next line of code to execute.
3. While in Break Mode – Navigate through code
When in break mode, you can debug interactively and see how your execution of code progresses. The basic features of code navigation are:
Continue (F5) will quit break mode and continue the program’s execution until the next breakpoint is hit, entering break-mode again.
Step Over (F10) will execute the current line and break on the next line of code.
Step Into (F11) is used when the next execution line is a method or a property. When clicked, the debugger will step into the method’s code first line. By default, properties are skipped. To enable stepping into property code go to Tools | Options | Debugging and uncheck Step over properties and operators.
Run execution to here allows you to continue execution, and break in a specified location without a breakpoint. It’s like creating a breakpoint and removing it after first break. You can do it in 3 ways:
- Hover and click on the green arrow that appears on the start of each line
- Stand on the desired line of code and click Ctrl + F10
- Right click on the desired line of code and click on Set next statement
Run to a cursor location allows you to forcefully set the next line of code to execute. The current (yellow) line will not be executed. It can be a line that was executed before or after, but it’s best for the new line of code to stay in the current scope. There are 2 ways to do this:
- Drag the yellow arrow to any line of code
- Stand on the desired line of code and click Ctrl+Shift+F10
4. Investigate variables
When in break mode, you can investigate the value of local variables and class members. This is as easy as hovering over a variable:
The hover popup is called a Data Tip. You can get to the same popup by right-clicking the variable and select QuickWatch (Shift+F9 or Ctrl+D, Q) in the context menu.
The data-tip and QuickWatch are very similar, except that you can edit the expression in QuickWatch.
An expression is a sequence of variables and operators that evaluate to a single value. For example, discountPercentage is an expression, initialPrice / 100 * discountPercentage is also an expression, literals like "Hello world" and 5 are also expressions.
For complex objects, you can expand into fields and properties.
5. DataTip and QuickWatch notable Features
The DataTip and QuickWatch have several useful features:
- Pinning DataTips – You can leave a DataTip pinned to the editor by clicking on the pin icon. Useful when you hit the same breakpoint many times (maybe in a loop)
- Holding Ctrl will make the DataTip transparent
- By right clicking on an expression in the DataTip, you can open a context menu with several options:
- Copy – Copies to clipboard both Expression and Value ( alex =
) - Copy Expression – Copies expression ( alex )
- Copy Value – Copies expression (
) - Edit Value – A useful feature where you can change the value during debugging. Most useful for primitives (strings, integers, etc.).
- Add Watch – Adds expression to Watch window (more on that later)
- Add Parallel Watch – Adds expression to Parallel Watch window (more on that later)
- Make Object ID – Creates a scope-independent expression that starts with ‘$’ ( $1 , $2 , and so on). You can evaluate this expression at any time, regardless of the current scope, in QuickWatch, Watch Window or the Immediate Window. A very useful feature and can be used to detect memory leaks .
6. Breakpoint advanced features
The breakpoints has several very useful lesser known features. By right-clicking a break you will see a context menu:
- Conditions allows you to break on this breakpoint only when a condition is met. For example, when in a loop I can break only on even numbers:
- Actions allow you to log a message to the output window whenever the breakpoint is hit. You can continue execution, without stopping on the breakpoint.
This is most useful when debugging multi-threaded scenarios. More on multi-threading debugging later.
- Edit labels… allows to categorize breakpoints into labels. This makes it easier later to organize them in the breakpoints tool window:
Summary
We covered the very basics of Visual Studio debugging, so I hope you feel comfortable with the material because the next tutorial will be more advanced.
In the next tutorial we will dive into Visual Studio tool windows. These include: The immediate window, Watch windows, Locals, Autos, Call Stack, Threads, Breakpoints, Exceptions, and output window.
There are other tool windows as well, but they are not part of the basic debugging features and we will cover them in their relevant context. These include the Modules window, Processes, Tasks, Parallel Watch, Parallel Stacks, Disassembly, and Memory window.
New tutorials coming soon, so keep following .
Welcome to my blog! I’m a software developer, C# enthusiast, author, and a blogger. I write about C#, .NET, memory management, and performance. Working at Microsoft, but all opinions in this blog are my own.
More about me →
Check out my book Practical Debugging for .NET Developers to become an expert problem solver
Отладка кода в Visual Studio
Для отладки определенной веб-страницы в Visual Studio выберите эту веб-страницу в окне Solution Explorer и щелкните на кнопке Start Debugging (Начать отладку) в панели инструментов. (Если вы в данный момент редактируете веб-страницу, которую собираетесь тестировать, то выбирать ее нет необходимости — просто щелкните на кнопке Start Debugging для ее запуска.)
Дальнейшие события зависят от расположения вашего проекта. Если ваш проект хранится на удаленном веб-сервере или локальном виртуальном каталоге IIS, Visual Studio просто запускает браузер по умолчанию и направляет на соответствующий URL.
Если вы использовали приложение файловой системы, Visual Studio запускает свой встроенный веб-сервер на динамически выбранном порту (который предотвращает конфликт с IIS, если он установлен). Затем Visual Studio запускает браузер по умолчанию и передает ему URL, указывающий на локальный веб-сервер. В каждом случае реальная работа — компиляция страницы и создание объектов страницы — передается рабочему процессу ASP NET.
Тестовый сервер запускается только на время работы Visual Studio и принимает запросы исключительно от данного компьютера. После запуска встроенного веб-сервера Visual Studio добавляет в область значков панели задач представляющий его значок. Чтобы получить дополнительную информацию о тестовом сервере или завершить его работу, необходимо дважды щелкнуть на этом значке.
Разделение Visual Studio, веб-сервера и ASP.NET предоставляет несколько интересных возможностей. Например, пока окно браузера открыто, можно по-прежнему вносить изменения в код и HTML-дескрипторы веб-страниц. Завершив внесение изменений, сохраните страницу и щелкните на кнопке Refresh (Обновить) в браузере для ее повторного запроса. Хотя всегда требуется перезапуск всей страницы для просмотра результатов внесенных изменений, это более удобно, нежели повторная сборка целиком всего проекта.
Фиксация и перезапуск веб-страницы полезны, но что делать, когда необходимо отследить трудно уловимую ошибку? В этих случаях понадобятся усовершенствованные возможности отладки Visual Studio, которые рассматриваются в последующих разделах.
Если тестовый веб-сервер используется, он запускает весь код от имени вашей пользовательской учетной записи. Это отличается от намного более ограниченного поведения, наблюдаемого в IIS, где для обеспечения безопасности применяется менее привилегированная учетная запись. Важно понимать разницу, поскольку, если приложение получает доступ к защищенным ресурсам (таким как файловая система, база данных, системный реестр или журнал регистрации событий), необходимо явно разрешить доступ пользователю IIS.
Пошаговая отладка
позволяет выполнять код по одной строке за раз. Выглядит она чрезвычайно просто и подразумевает выполнение следующих действий:
Найдите в коде точку, в которой необходимо приостановить выполнение, и начните пошаговое выполнение (можно использовать любую исполняемую строку кода, но не объявление переменной, комментарий или пустую строку). Щелкните на поле возле кода строки, после чего появится точка останова, помеченная красным цветом:
Теперь запустите свою программу обычным образом. Когда программа достигнет точки останова, выполнение приостановится, и вы переключитесь обратно в окно кода Visual Studio. Оператор, на котором установлена точка останова, не выполнится.
На этом этапе доступно несколько возможностей. Вы можете выполнить текущую строку, нажав клавишу <F11>. Следующая строка кода будет помечена желтой стрелкой, указывая на то, что именно она будет выполнена. Вы можете продолжать это на протяжении всей программы, запуская по одной строке за раз нажатием <F11> и следуя пути выполнения кода. Или же вы можете выйти из этого режима и возобновить нормальное выполнение кода, нажав клавишу <F5>.
Вместо клавиш быстрого вызова команд вроде <F11> и <F5> можно использовать кнопки панели инструментов Debug (Отладка) в Visual Studio. В качестве альтернативы можно щелкнуть правой кнопкой мыши в окне кода и выбрать опцию из контекстного меню.
Каждый раз, когда код находится в режиме паузы, можно поместить курсор над любой переменной и просмотреть ее содержимое. Это позволяет проверить, содержит ли переменная ожидаемое значение:
Если вы поместите курсор над объектом, то сможете просмотреть все его свойства, щелкнув на маленьком знаке «плюс»:
Можно даже непосредственно изменить значение переменной или свойства — просто щелкните внутри окна подсказки и введите новое значение. Это позволит смоделировать сценарии, которые сложно или долго воспроизвести вручную, либо проверить специфические условия ошибок.
В режиме паузы можно также использовать команды, перечисленные в таблице ниже. Эти команды доступны в контекстном меню, появляющемся после щелчка правой кнопкой мыши на окне кода, либо через соответствующие клавиши быстрого вызова команд.
Перевести программу в режим паузы можно в любой момент, щелкнув на кнопке паузы в панели инструментов или выбрав в меню Debug (Отладка) команду Break All (Остановить все).
Слежение за переменными
В некоторых случаях может понадобиться отслеживать состояние переменной без постоянного переключения в режим паузы. В таких ситуациях более полезными оказываются окна Locals (Локальные), Autos (Автоматические) и Watch (Слежение), которые позволяют отслеживать переменные во всем приложении:
| Окно | Описание |
|---|---|
| Locals | Автоматически отображает все переменные в пределах текущей процедуры, предлагая быстрый обзор важных переменных |
| Autos | Автоматически отображает переменные, которые система Visual Studio определила как важные для текущего оператора в коде. Сюда могут входить, например, переменные, к которым получается доступ или которые изменяются в предыдущей строке |
| Watch | Отображает добавленные вами переменные. Установки слежения сохраняются вместе с проектом, чтобы можно было продолжить слежение за переменными позже. Для добавления слежения щелкните правой кнопкой мыши на переменной в коде и выберите в контекстном меню пункт Add Watch (Добавить слежение); в качестве альтернативы дважды щелкните на последней строке в окне Watch и введите имя переменной |
Каждая строка в окнах Locals, Autos и Watch предоставляет информацию о типе или классе переменной и ее текущем значении. Если переменная содержит экземпляр объекта, ее можно развернуть и просмотреть приватные члены и свойства.
Например, в окне Locals вы увидите переменную this, которая является ссылкой на текущий объект страницы. Если вы щелкнете на знаке «плюс» возле нее, появится полный список свойств страницы (и некоторые системные значения):
Окна Locals, Autos и Watch позволяют изменять переменные или свойства во время нахождения программы в режиме паузы. Дважды щелкните на текущем значении в столбце Value (Значение) и введите новое значение. Если не хватает какого-то окна слежения, отобразите его вручную, выбрав его в подменю Windows меню Debug.
Расширенные точки останова
Выберите в меню Debug (Отладка) команду Windows —> Breakpoints для отображения окна, в котором перечислены все точки останова в текущем проекте. Окно Breakpoints (Точки останова) предоставляет счетчик попаданий в точку останова. Дважды щелкнув на точке останова, можно переместиться в соответствующее место кода:
Окно Breakpoints можно также применять для отключения точки останова без ее удаления. Это позволяет сохранить точку останова, чтобы использовать во время тестирования позже. Точки останова автоматически сохраняются в файле решения.
Visual Studio позволяет настраивать точки останова так, чтобы они проявлялись только в случае соблюдения определенных условий. Чтобы настроить точку останова, щелкните на ней правой кнопкой мыши и выберите одну из перечисленных ниже опций:
Location
Используйте эту опцию, если хотите увидеть точный файл и строку, в которой находится данная точка останова.
Condition
Используйте эту опцию, если хотите настроить выражение и сделать так, чтобы эта точка останова срабатывала только в случае, когда данное выражение будет истинным, или в случае его изменения с момента последнего срабатывания данной точки останова.
Hit Count
Используйте эту опцию, если хотите создать точку останова, которая будет приостанавливать процесс выполнения только либо после определенного количества срабатываний (например, хотя бы после 20), либо через определенное количество срабатываний (например, через каждые 5).
Filter
Используйте эту опцию, если хотите включить точку останова только для конкретных процессов или потоков. В ASP.NET эта опция применяется редко, поскольку весь код веб-страниц выполняется рабочим процессом ASP.NET, а он использует пул потоков.
When Hit
Используйте эту опцию, если хотите настроить действие, которое должно автоматически выполняться при каждом срабатывании точки останова. Существует два удобных варианта. Первый — указать в качестве такого действия вывод сообщения в окне Debug (Отладка), что позволит следить за ходом выполнения кода без его загромождения операторами Debug.Write(). Такой прием называется созданием точек трассировки (tracepoint).
Второй вариант — указать в качестве такого действия запуск макроса Visual Studio, что позволит выполнить в IDE-среде практически любое действие.
Отладка кода в Visual Studio
Всем доброго времени суток. На связи Алексей Гулынин. В прошлой статье мы познакомились с ключевыми словами ref и out в C#. В данной статье я бы хотел немного поговорить про отладку кода в Visual Studio.
В состав Visual Studio входит мощный отладчик, который позволяет расставлять точки остановки ( breakpoints ), запускать программу под этим отладчиком, пошагово её отлаживать. Пошагово можно отлаживать каждый оператор, можно отлаживать, входя в какой-то метод или не входя в метод. В любой момент можно посмотреть значение локальной переменной, вычислить какое-нибудь выражение. Можно посмотреть стек вызовов. Давайте на каком-нибудь примере разберем, как отлаживать код в Visual Studio :
Давайте поставим точку остановки. Это можно сделать двумя путями. Нажать клавишу "F9" , и на той строке, на которой находится курсор, будет точка остановки. Также можно нажать слева от строки на помеченную область:
Теперь можно запустить программу, и на брейкпойнте она остановится. Но остановка произойдёт только в том случае, если вы запустили программу под отладчиком. Самый простой способ запустить программу под отладчиком – это нажать клавишу F5 , а не Ctrl + F5 . Можно также через контекстное меню Debug :
Когда программа дойдёт до брейкпойнта, то её выполнение приостановится. Точка, на которой сейчас происходит выполнение программы, выделяется желтым цветом:
Пока программа приостановлена, можно посмотреть значение переменных. В Autos заносятся переменные автоматически, в Locals находятся локальные переменные, в Watch можно самим что-нибудь набрать (я набрал i*3 и i*5 ) и посмотреть результаты:
После этого можно нажать F5 и выполнение программы пойдёт дальше (или к следующему брейкпойнту, если такой имеется). В нашем случае программа перейдёт к следующему, так как у нас организован цикл. Также можно выполнить отладку по шагам. F10 – выполнить шаг без захода в метод (функцию), F11 – выполнить шаг с заходом в метод (функцию).
Домашнее задание: попробуйте написать программу, которая будет вычислять факториал числа и отладить её.
В данной небольшой статье вы узнали как просто можно отлаживать код в Visual Studio
На связи был Алексей Гулынин, оставляйте свои комментарии, увидимся в следующих статьях.
How to debug in visual studio? ( Tutorial to debug C# code )
If you have just started learning C# or you are new to Visual Studio IDE and want to learn more about it, one of the best features of visual studio is debugging code, which allows developer to check the output of any variable or output of each line statement while code is executing.
What is debugging?
Debugging is simply the process to identifying a problem, and then either correcting the problem or determining a way to work around it.
In Visual studio debugging, you can see how variables value changes while the program executes, and it is possible to see these changes. This is useful for when you want to make sure the values are correct and if they aren’t correct, you can determine a way to work around of the problem.
How to debug in Visual Studio?
To start understanding Visual Studio IDE debugging, we would have to create a sample C# console application program, I am using this simple C# program in Visual Studio, which uses variables and we will test how we can see variables output while debugging.
Sample C# Program
now, as you can see above, we will be using above program in Visual Studio to debug it, and also we can see debug menu available in Visual Studio.
Add the breakpoint in Visual Studio (C# program)
Now, we should add a breakpoint in our C# program.
On the far left of your source code tab, you will see a narrow gray strip, Click on it in the line you want to debug. The red circle will appear once you click it, it is where you have set the debugging breakpoint.
In the above code sample and image, we are debugging line » string stringValue = «Hello»; «, so when the red block is hit, it will open debugger and we can then debug code.
To Start debugging this code, press «Start» button in Visual Studio, here is the sample gif image
As you can see in the above gif image when the breakpoint is hit debugger opens and then you can hover over any variable and check it’s it value.
You can also see variables value, but navigating to «Debug -> Windows -> Locals», you should see output as below
Step-Through: Each and every line of code executed will be debugged. When a method call is invoked the flow enters the method and returns to the calling line after it has completed.
Disabling Debugger
- In the ASP.NET website, you can directly change the compilation tag’s debug attribute to false in web.config.
- In Windows applications, go to Project -> MyApplication Properties. Then change the Configure dropdown to Release.
Debugging tips in Visual Studio
1. Edit the value and continue
With Visual Studio 2012 or later, while debugging if you found any error in your code and want to change its value without stopping debugger or without rebuilding whole project, you can edit the value, save the changes and then continue debugging.
Edit-and-continue changes should be local, i.e., within one method. If you change the method signature, add new methods or classes, you’ll have to restart the app, or undo the changes to continue.
Note: You should have this feature enabled in your Visual Studio, to do this, you can navigate to «
Tools -> Options -> Debugging -> General > Check for ‘Enable Edit and Continue'»2. Set next statement by dragging and dropping yellow marker
You can just drag the yellow statement marker to the line you want to be executed next, like the function that has just failed, and then simply step in.
You can drag it above break-point also, just drag and drop the yellow marker to the line you want to execute next.
You can see the example of this in point number 4, when we are dragging cursor back to first line of code in Console program.
3. Hover over mouse to variable to evaluate it’s value
Things get easier with the debugger, you can simply point your mouse at a variable of interest. Moreover, classes and structures will be expanded with one click, allowing you to find the field you need quickly and conveniently.
4. Helpful Watch window
Every modern debugger has a watch window. However, in Visual Studio you can easily add and remove variables there.
You can open up watch windows from Debug -> Windows -> Watch (Ctrl+Alt+W,1).
Just click on the empty line, type your expression, and press Enter. Or simply press the delete button to remove an expression that is no longer needed.
5. Conditional breakpoints
You can create conditional breakpoints also, for this, set a breakpoint as usual. Right click it. Click Condition.
