Модул 17

Дебъгване и проследяване на изпълнението

Как да намерите грешка, която компилаторът не вижда: точки на прекъсване (обикновени и условни), клавишите F5/F10/F11, прозорците Locals, Autos, Watch и Call Stack, изследване на изключения и четене на stack trace. С примери във Visual Studio 2022 и .NET 8, сравнение с printf-дебъгването и работеща рецепта за откриване на логическа грешка.

Теория

Грешките в една програма са три вида. Синтактичните компилаторът хваща веднага и ги подчертава в червено, а грешките по време на изпълнение (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 BreakpointF9Поставя или маха точка на прекъсване на реда с курсораСъщото като щракване в сивото поле вляво от реда
Start Debugging / ContinueF5Стартира програмата под дебъгер; при пауза продължава до следващата точкаТочките спират само при стартиране с F5
Start Without DebuggingCtrl+F5Стартира програмата без дебъгерТочките на прекъсване се игнорират
Step OverF10Изпълнява текущия ред изцяло и спира на следващияИзвикан метод се изпълнява „наведнъж“
Step IntoF11Влиза в метода, извикан на текущия редАко няма извикване, действа като F10
Step OutShift+F11Довършва текущия метод и спира в извикващияСпасение, ако сте влезли с F11 по погрешка
Run to CursorCtrl+F10Изпълнява до реда с курсора и спира тамЕднократна точка на прекъсване
Stop / RestartShift+F5 / Ctrl+Shift+F5Спира програмата / стартира я отначалоРестартът запазва точките на прекъсване

Прозорци на дебъгера

ПрозорецОтварянеКакво показваКога е полезен
Подсказка (data tip)Мишката върху променлива при паузаСтойността на променливата; с кабърчето се закача на екранаНай-бързата проверка на една стойност
LocalsDebug > Windows > Locals (Ctrl+Alt+V, L)Всички променливи в текущия метод; променените при последната стъпка са в червеноОсновен прозорец при стъпково изпълнение
AutosCtrl+Alt+V, AПроменливите от текущия и предишния редДълги методи с много променливи
Watch 1Ctrl+Alt+W, 1Изрази, които сами добавяте: numbers[i], sum / countСледене на конкретен израз през цялата сесия
Call StackCtrl+Alt+CВеригата от методи до текущия ред; двойно щракване сменя рамкатаИзключения, вложени извиквания, рекурсия
ImmediateCtrl+Alt+IИзчислява въведен израз на C#, може да вика методиБърза проверка „какво би върнал“ без промяна на кода
BreakpointsCtrl+Alt+BСписък на всички точки с условията имВключване и изключване на много точки наведнъж
Exception SettingsCtrl+Alt+EКои изключения спират дебъгера още при хвърлянеКогато catch скрива грешката
OutputCtrl+Alt+OСъобщения от Debug.WriteLine и tracepointsprintf-дебъгване без спиране на програмата

Код за анализ и пренаписване

Проследяване на условна конструкция стъпка по стъпка

Program.cs
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: програмата спира при първата итерация, жълтата стрелка е върху реда, а в Locals points е 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 и ви държи във вашата програма.

Стек на извикванията и изследване на изключение

Program.cs
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 ...`. Кой ред показва мястото, където е възникнало изключението, и как да го откриете бързо във вашия код?

Речник на термините

Виж пълния речник на курса
Дебъгер (debugger)
Инструмент, който изпълнява програмата под контрол: спира я на избрани места, показва стойностите на променливите и позволява изпълнение ред по ред. Вграден е във Visual Studio и Visual Studio Code.
Точка на прекъсване (breakpoint)
Маркер върху ред от кода, при който дебъгерът спира изпълнението, преди да изпълни реда. Поставя се с F9 или с щракване в полето вляво от кода.
Условна точка на прекъсване (conditional breakpoint)
Точка на прекъсване, която спира само когато зададен израз е истина, например i == 734, или при определен брой преминавания (Hit Count).
Точка на проследяване (tracepoint)
Точка на прекъсване с действие: вместо да спира програмата, извежда съобщение със стойности на променливи в прозореца Output.
Стъпково изпълнение (stepping)
Изпълнение на програмата ред по ред с командите Step Over (F10), Step Into (F11) и Step Out (Shift+F11).
Locals, Autos, Watch
Прозорци за наблюдение на променливи: Locals показва всички в текущия метод, Autos — само тези от текущия и предишния ред, Watch — изрази, които сами сте добавили.
Стек на извикванията (call stack)
Веригата от методи, които са започнали и още не са завършили; всеки от тях е рамка (frame). Прозорецът Call Stack показва кой кого е извикал, от текущия метод до Main.
Stack trace
Текстовият запис на стека в момента на изключение: редове at Клас.Метод(...) in Файл.cs:line N, които се четат отгоре надолу — най-горе е мястото на хвърляне.
Логическа грешка (logic bug)
Грешка, при която програмата се компилира и работи без изключение, но дава грешен резултат. Открива се чрез сравняване на очакваните и реалните стойности в дебъгера.

Провери знанията

Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.

Провери знанията си

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, за да не ви изненадат при следващото пускане.

Учебен наръчник — теория, примери, задачи и тестове по предметите от учебния план.

Натисни Ctrl K или / отвсякъде, за да търсиш.