Теория
Грешките в една програма са три вида. Синтактичните компилаторът хваща веднага и ги подчертава в червено, а грешките по време на изпълнение (runtime errors) спират програмата с изключение, например IndexOutOfRangeException. Най-коварни са логическите грешки (logic bugs): програмата се компилира, работи, не гърми, но резултатът е грешен — средният успех излиза 4,00 вместо 5,25. За да ги открием, трябва да видим какво се случва вътре в програмата, докато тя работи, и точно за това служи дебъгерът (debugger) — инструмент, вграден във Visual Studio и Visual Studio Code, който спира изпълнението на избран ред, показва стойностите на променливите и позволява програмата да се изпълнява ред по ред. Най-простият начин да надникнете в програмата е да добавите Console.WriteLine на подозрителните места — така нареченото printf-дебъгване — но това променя кода, иска нова компилация за всяка променлива и после трябва да се чисти. Дебъгерът дава същата информация за всички променливи без промяна на кода, а когато все пак ви трябва извеждане, използвайте Debug.WriteLine от System.Diagnostics, което пише в прозореца Output и в Release се премахва.
Точка на прекъсване (breakpoint) е маркер върху ред от кода: щракнете в сивото поле вляво от реда или натиснете F9 и се появява червена точка. Стартирайте програмата с F5 (Start Debugging) — тя работи нормално, но щом стигне до маркирания ред, спира, преди да го изпълни. Жълтата стрелка върху реда показва следващата инструкция: редът с точката още не е изпълнен, затова променлива, която се присвоява на него, все още пази старата си стойност. Докато програмата е на пауза, F5 (Continue) я пуска до следващата точка, Shift+F5 я спира, а Ctrl+Shift+F5 я рестартира. Ако стартирате с Ctrl+F5 (Start Without Debugging), точките на прекъсване се игнорират — това е най-честата причина за въпроса „защо не спира?“.
Спряната програма може да се изпълнява стъпка по стъпка (stepping). F10 (Step Over) изпълнява текущия ред изцяло и спира на следващия; ако редът вика метод, методът се изпълнява „наведнъж“. F11 (Step Into) влиза в извикания метод и спира на първия му ред, а Shift+F11 (Step Out) довършва текущия метод и връща в извикващия. При условни конструкции стъпковото изпълнение е най-нагледният начин да се види кой клон се изпълнява: стрелката минава през if (points >= 90), условието е невярно и тя прескача целия блок до else if. Така проверявате дали сте написали > вместо >= на границата, без да гадаете по изхода. Благодарение на настройката Just My Code F11 не влиза в кода на .NET (например в Console.WriteLine), а само във ваши методи.
Докато програмата е на пауза, задръжте мишката върху променлива и ще видите стойността ѝ в подсказка (data tip); с кабърчето можете да я закачите на екрана. Прозорецът Locals (Debug > Windows > Locals) показва всички променливи в текущия метод, а тези, които са се променили при последната стъпка, светят в червено — именно те заслужават внимание. Autos показва само променливите от текущия и предишния ред, което е удобно при дълги методи. В Watch сами добавяте изрази — numbers[i], sum / count, name.Length — и ги следите през цялата сесия. В прозореца Immediate (Ctrl+Alt+I) пишете произволен израз на C#, например GetGrade(59), и веднага получавате резултата. Стойността на променлива може дори да се редактира направо в Locals, за да проверите „какво би станало, ако…“, без да спирате програмата.
В цикъл с хиляда итерации грешката често е в една-единствена. Вместо да натискате F5 стотици пъти, щракнете с десен бутон върху точката на прекъсване и изберете Conditions: условието е обикновен израз на C#, например i == 734 или name == "Петър", и дебъгерът спира само когато то е вярно — това е условна точка на прекъсване (conditional breakpoint). Другият вариант е Hit Count — спиране при N-тото преминаване през реда. С Actions превръщате точката в tracepoint: тя не спира програмата, а извежда съобщение в прозореца Output, например i = {i}, sum = {sum} (променливите се ограждат с фигурни скоби) — printf-дебъгване без нито един нов ред код. Всички точки с техните условия се виждат в прозореца Breakpoints (Ctrl+Alt+B), където можете временно да ги изключите, вместо да ги триете.
Методите се викат един друг и всеки незавършил метод е рамка (frame) в стека на извикванията (call stack). Прозорецът Call Stack (Ctrl+Alt+C) показва тази верига: най-отгоре е методът, в който сте спрели, под него — този, който го е извикал, и така надолу до Main; с двойно щракване върху рамка виждате в Locals променливите на този метод и разбирате с какви аргументи е била извикана функцията, която гърми. Когато програмата хвърли необработено изключение под дебъгер, тя спира на реда с throw, а Exception Helper показва типа и съобщението; самото изключение е достъпно в Watch като $exception със свойствата Message, StackTrace и InnerException. Ако изключението е хванато от catch и затова дебъгерът не спира, отворете Exception Settings (Ctrl+Alt+E) и отметнете Common Language Runtime Exceptions — тогава спирането става в момента на хвърлянето. Текстовият stack trace, който се извежда при срив, е същият стек като текст: четете го отгоре надолу, всеки ред at Namespace.Class.Method(...) in File.cs:line N е рамка, а първият ред, в който се споменава ваш файл, е мястото за първата точка на прекъсване.
Търсенето на логическа грешка върви по една и съща рецепта. Първо възпроизведете грешката с конкретен вход, при който резултатът е гарантирано грешен — без това не знаете дали сте я оправили. Второ, стеснете областта: поставете точка на прекъсване близо до подозрителното място (например при return или преди извеждането на резултата), а не в началото на Main. Трето, на всяка стъпка сравнявайте очакваното с реалното: запишете на лист какви стойности трябва да имат променливите за вашия вход и проверявайте в Locals — първата стойност, която се разминава, сочи към реда с грешката. Четвърто, формулирайте хипотеза („граничното условие е < вместо <=“), поправете само нея и пуснете отново същия вход, а после и още няколко гранични: 0, 1, празен масив, най-големият елемент на последно място. Тази дисциплина — възпроизведи, стесни, сравни, поправи, провери — е по-важна от всеки клавиш.
Златни правила
Първо възпроизведи, после дебъгвай
Намерете конкретен вход, при който грешката се появява всеки път. Без сигурно възпроизвеждане не можете да проверите дали поправката работи.
Жълтата стрелка сочи какво предстои
Редът, на който е спрял дебъгерът, още не е изпълнен. Променлива, присвоявана на този ред, показва старата си стойност, докато не натиснете F10.
Спирай близо до проблема
Точката на прекъсване се слага до подозрителното място, а не в началото на Main. При цикли използвайте условие или Hit Count, вместо да натискате F5 стотици пъти.
Сравнявай очакваното с реалното
На всяка стъпка знайте каква стойност трябва да има променливата и я проверявайте в Locals. Първото разминаване сочи реда с грешката.
Stack trace се чете отгоре надолу
Най-горният ред at ... е мястото на хвърляне, най-долният е Main. Първият ред с ваш файл и line N показва къде да сложите първата точка на прекъсване.
Бърз справочник
Команди и клавиши на дебъгера (Visual Studio 2022)
| Команда | Клавиш | Какво прави | Бележка |
|---|---|---|---|
| Toggle Breakpoint | F9 | Поставя или маха точка на прекъсване на реда с курсора | Същото като щракване в сивото поле вляво от реда |
| Start Debugging / Continue | F5 | Стартира програмата под дебъгер; при пауза продължава до следващата точка | Точките спират само при стартиране с F5 |
| Start Without Debugging | Ctrl+F5 | Стартира програмата без дебъгер | Точките на прекъсване се игнорират |
| Step Over | F10 | Изпълнява текущия ред изцяло и спира на следващия | Извикан метод се изпълнява „наведнъж“ |
| Step Into | F11 | Влиза в метода, извикан на текущия ред | Ако няма извикване, действа като F10 |
| Step Out | Shift+F11 | Довършва текущия метод и спира в извикващия | Спасение, ако сте влезли с F11 по погрешка |
| Run to Cursor | Ctrl+F10 | Изпълнява до реда с курсора и спира там | Еднократна точка на прекъсване |
| Stop / Restart | Shift+F5 / Ctrl+Shift+F5 | Спира програмата / стартира я отначало | Рестартът запазва точките на прекъсване |
Прозорци на дебъгера
| Прозорец | Отваряне | Какво показва | Кога е полезен |
|---|---|---|---|
| Подсказка (data tip) | Мишката върху променлива при пауза | Стойността на променливата; с кабърчето се закача на екрана | Най-бързата проверка на една стойност |
| Locals | Debug > Windows > Locals (Ctrl+Alt+V, L) | Всички променливи в текущия метод; променените при последната стъпка са в червено | Основен прозорец при стъпково изпълнение |
| Autos | Ctrl+Alt+V, A | Променливите от текущия и предишния ред | Дълги методи с много променливи |
| Watch 1 | Ctrl+Alt+W, 1 | Изрази, които сами добавяте: numbers[i], sum / count | Следене на конкретен израз през цялата сесия |
| Call Stack | Ctrl+Alt+C | Веригата от методи до текущия ред; двойно щракване сменя рамката | Изключения, вложени извиквания, рекурсия |
| Immediate | Ctrl+Alt+I | Изчислява въведен израз на C#, може да вика методи | Бърза проверка „какво би върнал“ без промяна на кода |
| Breakpoints | Ctrl+Alt+B | Списък на всички точки с условията им | Включване и изключване на много точки наведнъж |
| Exception Settings | Ctrl+Alt+E | Кои изключения спират дебъгера още при хвърляне | Когато catch скрива грешката |
| Output | Ctrl+Alt+O | Съобщения от Debug.WriteLine и tracepoints | printf-дебъгване без спиране на програмата |
Код за анализ и пренаписване
Проследяване на условна конструкция стъпка по стъпка
using System;
namespace DebugDemo
{
class Program
{
// Връща словесна оценка по точки от тест (0-100)
static string GetGrade(int points)
{
string grade;
if (points >= 90)
{
grade = "Отличен";
}
else if (points >= 75)
{
grade = "Много добър";
}
else if (points >= 60)
{
grade = "Добър";
}
else
{
grade = "Слаб";
}
return grade;
}
static void Main(string[] args)
{
int[] results = { 95, 75, 59, 60 };
foreach (int points in results)
{
string grade = GetGrade(points); // точка на прекъсване (F9) тук
Console.WriteLine($"{points} точки -> {grade}");
}
}
}
}Какво се случва тук?
- Поставете точка на прекъсване с
F9на редаstring grade = GetGrade(points);вMainи натиснетеF5: програмата спира при първата итерация, жълтата стрелка е върху реда, а в Localspointsе95, докатоgradeеnull, защото редът още не е изпълнен. - Натиснете
F11: дебъгерът влиза вGetGradeи спира на първия му ред; в Locals вече виждате параметъраpoints = 95и локалнатаgrade = null, а в Call Stack има две рамки —GetGradeотгоре иMainпод нея. - Продължете с
F10: стрелката минава презif (points >= 90), условието е вярно и попада в блокаgrade = "Отличен"; после прескача всичкиelse ifиelseи отива направо наreturn grade;— точно това е проследяването на условна конструкция. -
Shift+F11довършва метода и ви връща вMainна същия ред; още едноF10завършва присвояването иgradeсветва в червено със стойност"Отличен". - При следващите итерации (
F5до точката, послеF11) за75ще видите, че първото условие е невярно и стрелката прескача къмelse if (points >= 75); за59тя стига чак доelse, а за60влиза вelse if (points >= 60). - Стойностите на границата (
59,60,75) са тези, при които се крие грешка от типа>вместо>=; със стъпково изпълнение я виждате с очите си, вместо да гадаете по изхода. - Ако натиснете
F11на реда сConsole.WriteLine, дебъгерът няма да влезе в него — настройката Just My Code прескача кода на .NET и ви държи във вашата програма.
Стек на извикванията и изследване на изключение
using System;
using System.Diagnostics;
namespace DebugDemo
{
class Program
{
static double CalculateDiscount(double price, int percent)
{
if (percent < 0 || percent > 100)
{
throw new ArgumentOutOfRangeException(nameof(percent),
$"Отстъпката трябва да е между 0 и 100, а е {percent}.");
}
return price * percent / 100.0;
}
static double FinalPrice(double price, int percent)
{
double discount = CalculateDiscount(price, percent);
Debug.WriteLine($"price={price}, percent={percent}, discount={discount}");
return price - discount;
}
static void Main(string[] args)
{
double[] prices = { 100, 250 };
int[] discounts = { 10, 120 };
for (int i = 0; i < prices.Length; i++)
{
try
{
double final = FinalPrice(prices[i], discounts[i]);
Console.WriteLine($"Цена {prices[i]} с {discounts[i]}% отстъпка: {final}");
}
catch (ArgumentOutOfRangeException ex)
{
Console.WriteLine("Грешка: " + ex.Message);
Console.WriteLine(ex.StackTrace);
}
}
}
}
}Какво се случва тук?
- Стартирайте с
F5без точки на прекъсване: първата цена минава нормално, а приpercent = 120методътCalculateDiscountхвърляArgumentOutOfRangeException; понеже вMainимаcatch, дебъгерът не спира, а конзолата извежда съобщението и stack trace от три редаat ...—CalculateDiscount,FinalPriceиMain, отгоре надолу. - Отворете Exception Settings (
Ctrl+Alt+E), отметнетеCommon Language Runtime Exceptionsи рестартирайте сCtrl+Shift+F5: сега дебъгерът спира на реда сthrowв момента на хвърлянето, а Exception Helper показва типа и текста на съобщението. - В прозореца Call Stack виждате три рамки:
CalculateDiscountс жълтата стрелка, под неяFinalPrice, най-отдолуMain; щракнете два пъти върхуFinalPriceи в Locals ще видитеprice = 250иpercent = 120— аргументите, с които е била извикана проблемната функция. - В Watch добавете
$exceptionи разгънете обекта:Messageсъдържа текста отthrowплюс добавката(Parameter 'percent'), коятоArgumentOutOfRangeExceptionприбавя сама зарадиnameof(percent). - Редът
Debug.WriteLine(...)въвFinalPriceе printf-дебъгване по правилата: изискваusing System.Diagnostics;, пише в прозореца Output (Ctrl+Alt+O), а не в конзолата, и в Release компилаторът го премахва изцяло, защото методът е маркиран с[Conditional("DEBUG")]. - За втората цена съобщение в Output липсва: изключението прекъсва
FinalPrice, преди да се стигне до реда сDebug.WriteLine, което само по себе си е улика къде е гръмнало. -
catch (ArgumentOutOfRangeException ex)обработва само този тип и цикълът продължава; ако махнетеtry/catch, същото изключение става необработено и дебъгерът ще спре наthrowдори без промяна в Exception Settings.
Внимавай! Чести грешки
Грешките, които почти всеки прави в тази тема — виж разликата между грешния и правилния код.
Четене на променлива, която още не е присвоена
Грешно
int sum = Add(a, b); // точка на прекъсване тук
// В Locals: sum = 0 -> "Add не работи!?"
Console.WriteLine(sum);Правилно
int sum = Add(a, b);
Console.WriteLine(sum); // точка на прекъсване тук: sum вече е изчислена
// или: спрете на горния ред и натиснете F10 веднъжДебъгерът спира преди да изпълни реда с точката на прекъсване, затова sum още пази стойността по подразбиране. Резултатът се вижда едва на следващия ред или след една стъпка с F10.
Временни Console.WriteLine, останали в готовата програма
Грешно
static int Max(int a, int b)
{
Console.WriteLine("DEBUG a=" + a + " b=" + b);
return a > b ? a : b;
}Правилно
using System.Diagnostics;
static int Max(int a, int b)
{
Debug.WriteLine($"Max: a={a}, b={b}");
return a > b ? a : b;
}Console.WriteLine замърсява изхода за потребителя и лесно се забравя в кода. Debug.WriteLine пише в прозореца Output и в Release компилаторът го премахва; а най-чистият вариант е tracepoint, който не изисква промяна на кода изобщо.
Условие или Watch, което променя програмата
Грешно
// Условие на точката на прекъсване:
found = true
// Израз в Watch:
counter++Правилно
// Условие на точката на прекъсване:
found == true
// Израз в Watch:
counterЕдиничното = е присвояване: условието found = true всеки път записва true в променливата и програмата се държи различно под дебъгер. Изразите в условия и в Watch трябва само да четат — counter++ увеличава брояча всеки път, когато дебъгерът изчисли израза — при добавянето му и при всяко ръчно опресняване — и така променя програмата, която уж само наблюдавате.
Празен catch, който скрива грешката
Грешно
try
{
int n = int.Parse(input);
total += n;
}
catch (Exception)
{
// нищо - "за да не гърми"
}Правилно
try
{
int n = int.Parse(input);
total += n;
}
catch (FormatException ex)
{
Console.WriteLine($"Невалидно число '{input}': {ex.Message}");
}Празният catch поглъща изключението и програмата тихо продължава с грешна сума — най-трудната за откриване логическа грешка. Хващайте конкретния тип и съобщавайте за проблема; при дебъгване Exception Settings показва и „скритите“ изключения.
Задачи за самостоятелна работа
Опитай първо сам — подсказката е там само ако наистина закъсаш.
Кой клон се изпълни?
Напишете програма, която чете от конзолата три цели числа и извежда най-голямото, като използва само if / else if / else (без Math.Max). Поставете точка на прекъсване на първия if, стартирайте с F5 и с F10 проследете кой клон се изпълнява за входовете 5 7 3, 9 2 4 и 1 1 1. Над всеки клон добавете коментар при кой от входовете се е изпълнил, а в Locals проверете стойността на max преди и след присвояването.
Условна точка на прекъсване и tracepoint
Напишете метод static int SumEven(int[] numbers), който връща сумата на четните числа в масива, и го извикайте от Main с масива { 3, 8, 5, 12, 7, 10 } — очакваният резултат е 30. Поставете точка на прекъсване на реда с if вътре в цикъла и ѝ задайте условие numbers[i] % 2 == 0, така че дебъгерът да спира само при четните елементи, макар редът да се изпълнява за всеки. При всяко спиране запишете стойностите на i, numbers[i] и sum от Locals. После превърнете точката в tracepoint (Actions), който извежда i = {i}, sum = {sum} в прозореца Output, без да спира програмата.
Стекът при изключение
Напишете програма с метод static double Average(List<int> grades), който хвърля ArgumentException при празен списък, и метод static void PrintReport(string name, List<int> grades), който извежда името и средния успех. От Main извикайте PrintReport за двама ученици, като вторият е с празен списък. Първо пуснете програмата без try/catch: когато дебъгерът спре на throw, отворете Call Stack, запишете трите рамки и с двойно щракване върху PrintReport вижте в Locals кое name е предизвикало грешката. После обработете изключението в Main с try/catch, изведете ex.Message и ex.StackTrace и се уверете, че първият ученик пак се отчита, а програмата не се срива.
Мини-тест за проверка
Отговори си наум (или на глас!) и чак тогава разкрий отговора.
1. Спрели сте на реда `double average = Average(grades);`. Какво ще се случи, ако натиснете `F10`, и какво — ако натиснете `F11`?
2. Дебъгерът е спрял на точка на прекъсване върху реда `int result = Compute(x);`. Каква стойност ще покаже Locals за `result` и защо?
3. Цикъл с 1000 итерации дава грешен резултат някъде по средата. Как да спрете точно при `i == 734`, без да натискате `F5` стотици пъти?
4. Програмата се срива и извежда stack trace от пет реда с `at ...`. Кой ред показва мястото, където е възникнало изключението, и как да го откриете бързо във вашия код?
Речник на термините
Виж пълния речник на курсаF9 или с щракване в полето вляво от кода.i == 734, или при определен брой преминавания (Hit Count).F10), Step Into (F11) и Step Out (Shift+F11).Main.at Клас.Метод(...) in Файл.cs:line N, които се четат отгоре надолу — най-горе е мястото на хвърляне.Провери знанията
Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.
Провери знанията си
9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.
Материали от часовете
Задачи и тестове, давани в клас по тази тема.
Препоръки за този модул
- Преди да натиснете
F5, запишете на лист какви стойности очаквате за променливите при конкретния вход. Дебъгерът показва какво е, но само вие знаете какво трябва да е — без очакване няма какво да сравнявате. - Дебъгвайте в конфигурация Debug и стартирайте с
F5, не сCtrl+F5. В Release компилаторът оптимизира и променливи могат да „изчезнат“ от Locals, а без дебъгер точките на прекъсване просто не спират. - Научете петте клавиша
F9,F5,F10,F11иShift+F11до автоматизъм — упражнете ги върху програма от десет реда, преди да ви потрябват при истинска грешка. Във Visual Studio Code с разширението C# Dev Kit клавишите са същите, а прозорците се казват Variables, Watch и Call Stack. - При цикли и рекурсия не натискайте
F5до безкрай: задайте условие или Hit Count на точката, или я превърнете в tracepoint и прочетете стойностите наведнъж в Output. Когато приключите, изтрийте или изключете точките през прозореца Breakpoints, за да не ви изненадат при следващото пускане.