Основи Відлагодження (Debugging Basics)

Вступ та Контекст

Уявіть собі ситуацію: ваша програма компілюється без помилок, але при виконанні видає неочікуваний результат. Користувачі скаржаться, що їхні замовлення обробляються з неправильними цінами. Де саме виникає проблема? Яка змінна містить некоректне значення? У якій послідовності викликаються методи?

Саме для вирішення таких задач існує відлагодження (debugging) — процес виявлення та усунення помилок у коді. Відлагоджувач (debugger) — це потужний інструмент, який дозволяє зупиняти виконання програми, інспектувати стан змінних, покроково виконувати код та аналізувати потік виконання.

Що ви отримаєте

Після вивчення цього розділу ви зможете:

• Ефективно використовувати breakpoints (точки зупинки) для аналізу коду
• Інспектувати змінні через Locals, Watch та Call Stack вікна
• Навігувати по коду за допомогою Step Into, Step Over та Step Out
• Виконувати код "на льоту" через Immediate Window
• Швидко діагностувати та виправляти типові помилки

Передумови

Для роботи з цим розділом вам необхідно:

• Встановлене середовище розробки (Visual Studio або Visual Studio Code з C# Dev Kit)
• Базове розуміння синтаксису C# (змінні, методи, класи)
• Знання про типи даних та control flow

Фундаментальні Концепції

Що таке відлагодження?

Відлагодження (Debugging) — це систематичний процес виявлення, локалізації та усунення помилок (bugs) у програмному коді. Це не просто "виправлення того, що не працює", а наукова методика аналізу поведінки програми на різних рівнях абстракції.

Життєвий цикл відлагодження

graph LR
    A[Виявлення проблеми] --> B[Відтворення помилки]
    B --> C[Локалізація причини]
    C --> D[Аналіз stану програми]
    D --> E[Виправлення коду]
    E --> F[Верифікація рішення]
    F --> G{Помилка усунена?}
    G -->|Ні| B
    G -->|Так| H[Завершення]

    style A fill:#64748b,stroke:#334155,color:#ffffff
    style B fill:#64748b,stroke:#334155,color:#ffffff
    style C fill:#64748b,stroke:#334155,color:#ffffff
    style D fill:#64748b,stroke:#334155,color:#ffffff
    style E fill:#f59e0b,stroke:#b45309,color:#ffffff
    style F fill:#64748b,stroke:#334155,color:#ffffff
    style G fill:#f59e0b,stroke:#b45309,color:#ffffff
    style H fill:#3b82f6,stroke:#1d4ed8,color:#ffffff

Visual Studio Debugger

Visual Studio надає один з найпотужніших відлагоджувачів для .NET розробки. Він інтегрований безпосередньо в IDE та підтримує:

• Interactive debugging: Зупинка виконання в будь-який момент
• Data inspection: Перегляд та модифікація змінних у реальному часі
• Navigation: Покрокове виконання коду з повним контролем
• Expression evaluation: Виконання C# виразів під час паузи

Breakpoints (Точки Зупинки)

Breakpoint — це маркер у коді, який інструктує відлагоджувач призупинити виконання програми у вказаному місці. Це найбазовіший та найважливіший інструмент відлагодження.

Встановлення Breakpoints

Керування Breakpoints

using System;

class Program
{
    static void Main()
    {
        int sum = 0; // ← Breakpoint тут (рядок 7)

        for (int i = 1; i <= 5; i++)
        {
            sum += i; // ← Breakpoint тут (рядок 11)
            Console.WriteLine($"Ітерація {i}: sum = {sum}");
        }

        Console.WriteLine($"Підсумок: {sum}"); // ← Breakpoint тут (рядок 15)
    }
}

Операції з breakpoints:

Conditional Breakpoints (Умовні Точки Зупинки)

Conditional breakpoints зупиняють виконання лише тоді, коли виконується певна умова. Це надзвичайно корисно для відлагодження циклів або рідкісних сценаріїв.

public class OrderProcessor
{
    public void ProcessOrders(List<Order> orders)
    {
        foreach (var order in orders)
        {
            decimal total = CalculateTotal(order);             // Умовний breakpoint: total > 1000

            if (total > 0)
            {
                order.Status = "Processed";
            }
        }
    }

    private decimal CalculateTotal(Order order)
    {
        return order.Items.Sum(i => i.Price * i.Quantity);
    }
}

Встановлення умовного breakpoint:

// Зупинитися, коли сума перевищує 1000
total > 1000

// Зупинитися для конкретного користувача
string.IsNullOrEmpty(name)

// Зупинитися при комбінації умов
order.Status == "Pending" && order.Total > 500

Hit Count Breakpoints

Hit Count breakpoints зупиняють виконання після певної кількості проходжень через breakpoint.

Приклад: Зупинитися на 100-й ітерації циклу.

Debugging Windows (Вікна Відлагодження)

Коли програма зупинена на breakpoint, Visual Studio надає кілька вікон для інспекції стану програми.

Locals Window (Вікно Локальних Змінних)

Locals Window автоматично відображає всі локальні змінні у поточному scope (області видимості), включаючи параметри методу.

public decimal CalculateDiscount(decimal price, int quantity)
{
    decimal subtotal = price * quantity; // ← Breakpoint тут
    decimal discount = 0;

    if (subtotal > 100)
    {
        discount = subtotal * 0.1m; // 10% знижка
    }

    return subtotal - discount;
}

Що показує Locals Window на breakpoint (рядок 3):

Watch Window (Вікно Спостереження)

Watch Window дозволяє додавати власні вирази та змінні для постійного моніторингу, навіть якщо вони не входять у поточний scope.

Відкрити: Debug → Windows → Watch → Watch 1 або Ctrl+Alt+W, 1

public class ShoppingCart
{
    private List<Item> items = new List<Item>();

    public void AddItem(Item item)
    {
        items.Add(item); // ← Breakpoint тут

        // Додайте у Watch:
        // items.Count
        // items.Sum(i => i.Price)
        // item.Name
    }
}

Вирази для Watch Window:

Call Stack Window (Вікно Стека Викликів)

Call Stack показує ланцюжок викликів методів, які привели до поточної точки виконання. Це критично важливо для розуміння контексту виконання.

class Program
{
    static void Main(string[] args)
    {
        ProcessData(); // [1] Точка входу
    }

    static void ProcessData()
    {
        var result = CalculateSum(10, 20); // [2] Виклик CalculateSum
        Console.WriteLine(result);
    }

    static int CalculateSum(int a, int b)
    {
        return Add(a, b); // [3] Виклик Add ← Breakpoint тут
    }

    static int Add(int x, int y)
    {
        return x + y; // [4] Поточне місце виконання
    }
}

Call Stack на breakpoint (рядок 20):

Add(int x, int y) Line 20          ← Поточний frame
CalculateSum(int a, int b) Line 15
ProcessData() Line 10
Main(string[] args) Line 5
[External Code]

Відкрити: Debug → Windows → Call Stack або Ctrl+Alt+C

graph TB
    A[Main] --> B[ProcessData]
    B --> C[CalculateSum]
    C --> D[Add ← Ми тут]

    style A fill:#64748b,stroke:#334155,color:#ffffff
    style B fill:#64748b,stroke:#334155,color:#ffffff
    style C fill:#64748b,stroke:#334155,color:#ffffff
    style D fill:#f59e0b,stroke:#b45309,color:#ffffff

Використання Call Stack:

Step-Through Debugging (Покрокове Виконання)

Після зупинки на breakpoint ви можете контролювати виконання коду по рядках.

Основні Команди Навігації

public class Calculator
{
    public int Calculate(int a, int b)
    {
        int result = Add(a, b);     // [1] Breakpoint тут
        result = Multiply(result, 2); // [2]
        return result;                // [3]
    }

    private int Add(int x, int y)
    {
        return x + y;                 // [4]
    }

    private int Multiply(int x, int y)
    {
        return x * y;                 // [5]
    }
}

Практичний Сценарій

Візуалізація Flow Execution

sequenceDiagram
    participant User
    participant Calculate
    participant Add
    participant Multiply

    User->>Calculate: Calculate(5, 3)
    Note over Calculate: Breakpoint на рядку [1]

    alt F11 (Step Into)
        Calculate->>Add: Add(5, 3)
        Note over Add: Заходимо всередину
        Add-->>Calculate: return 8
    end

    alt F10 (Step Over)
        Calculate->>Multiply: Multiply(8, 2)
        Note over Calculate: Виконується цілком
        Multiply-->>Calculate: return 16
    end

    alt Shift+F11 (Step Out)
        Calculate-->>User: return 16
        Note over User: Вихід з методу
    end

    style User fill:#3b82f6,stroke:#1d4ed8,color:#ffffff
    style Calculate fill:#64748b,stroke:#334155,color:#ffffff
    style Add fill:#f59e0b,stroke:#b45309,color:#ffffff
    style Multiply fill:#f59e0b,stroke:#b45309,color:#ffffff

Run to Cursor (Виконати до Курсору)

Run to Cursor — це швидкий спосіб виконати код до певного рядка без встановлення breakpoint.

Immediate Window (Вікно Негайного Виконання)

Immediate Window — це інтерактивна консоль, яка дозволяє виконувати C# вирази та команди під час паузи виконання.

Відкрити: Debug → Windows → Immediate або Ctrl+Alt+I

Оцінка Виразів

public void ProcessOrder(Order order)
{
    string customerName = order.Customer.Name;
    decimal total = order.CalculateTotal(); // ← Breakpoint тут

    if (total > 100)
    {
        ApplyDiscount(order);
    }
}

У Immediate Window (коли breakpoint активний):

// Перевірка значень
? customerName
"John Doe"

? total
125.50m

// Виклик методів
? order.Items.Count
3

// LINQ запити
? order.Items.Where(i => i.Price > 20).Count()
2

// Математичні операції
? total * 0.1
12.55m

// Умовні вирази
? total > 100
true

Виконання Коду "На Льоту"

Immediate Window дозволяє не тільки читати, але й змінювати стан програми:

// Змінити значення змінної
total = 50.0m

// Викликати метод
order.AddItem(new Item { Name = "Test", Price = 10 })

// Створити новий об'єкт
var testCustomer = new Customer { Name = "Test User" }

// Invoke приватні методи (через рефлексію)
? this.GetType().GetMethod("PrivateMethod",
    BindingFlags.NonPublic | BindingFlags.Instance)
    .Invoke(this, null)

Практичні Use Cases

? DateTime.Now.AddDays(7).DayOfWeek
DayOfWeek.Monday

? order.GetType().GetField("_internalId",
    BindingFlags.NonPublic | BindingFlags.Instance).GetValue(order)

total = decimal.MaxValue
? order.CalculateTotal()
// Перевірка overflow handling

Практичний Debugging Workflow

Розглянемо повний цикл відлагодження реальної проблеми.

Сценарій: Некоректна Знижка

public class PriceCalculator
{
    public decimal ApplyDiscount(decimal price, decimal discountPercent)
    {
        decimal discount = price * discountPercent;
        return price - discount;
    }
}

// Виклик:
var calculator = new PriceCalculator();
var finalPrice = calculator.ApplyDiscount(100, 20);
// Очікуємо: 80, Отримуємо: -1900 (?!)

Процес Відлагодження

price = 100
discountPercent = 20
discount = 2000  ← Проблема!

? price * discountPercent
2000m  // Має бути 20!

? discountPercent / 100
0.20m  // Ось правильне значення!

public decimal ApplyDiscount(decimal price, decimal discountPercent)
{
    // Конвертуємо відсотки у десятковий формат
    decimal discount = price * (discountPercent / 100);
    return price - discount;
}

Debugging Checklist

Troubleshooting (Вирішення Типових Проблем)

Breakpoint не спрацьовує

Можливі причини та рішення:

<PropertyGroup>
  <DebugType>full</DebugType>
  <DebugSymbols>true</DebugSymbols>
</PropertyGroup>

Locals/Watch показує "Cannot evaluate expression"

Immediate Window не працює

Надто повільне відлагодження

Оптимізації:

• Використовуйте Hit Count breakpoints замість складних умов
• Видаліть непотрібні Watch вирази
• Вимкніть "Enable property evaluation and other implicit function calls" в налаштуваннях Debug

Практичні Завдання

Закріпіть знання через практику!

Рівень 1: Основи Breakpoints

int sum = 0;
for (int i = 1; i <= 10; i++)
{
    sum += i;
}
Console.WriteLine($"Сума: {sum}");

for (int i = 1; i <= 100; i++)
{
    if (i % 7 == 0)
    {
        Console.WriteLine($"Знайдено: {i}");
    }
}

Рівень 2: Watch та Step-Through

public class Student
{
    public string Name { get; set; }
    public List<int> Grades { get; set; } = new List<int>();

    public double GetAverage()
    {
        return Grades.Average(); // Breakpoint тут
    }
}

var student = new Student { Name = "Іван" };
student.Grades.AddRange(new[] { 85, 90, 78, 92, 88 });
var avg = student.GetAverage();

public int Calculate(int a, int b)
{
    int sum = Add(a, b);        // [1] Breakpoint
    int product = Multiply(a, b); // [2]
    return sum + product;         // [3]
}

private int Add(int x, int y) => x + y;
private int Multiply(int x, int y) => x * y;

// Виклик:
Calculate(3, 4);

Рівень 3: Складні Сценарії

public int Factorial(int n)
{
    if (n <= 1)
        return 1;  // [Base case]

    return n * Factorial(n - 1); // [Recursive call] ← Breakpoint
}

// Виклик:
int result = Factorial(5);

public class BankAccount
{
    private decimal balance;

    public void Deposit(decimal amount)
    {
        balance += amount; // Breakpoint тут
    }

    public bool Withdraw(decimal amount)
    {
        if (balance >= amount)
        {
            balance -= amount;
            return true;
        }
        return false;
    }
}

var account = new BankAccount();
account.Deposit(1000);
account.Withdraw(300);
account.Withdraw(500);

public List<int> GetEvenNumbers(List<int> numbers)
{
    var result = new List<int>();

    for (int i = 0; i < numbers.Count; i++)
    {
        if (numbers[i] % 2 == 0)
        {
            result.Add(numbers[i]);
        }
        i++; // ← Є тут проблема?
    }

    return result;
}

// Тест:
var input = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 };
var evens = GetEvenNumbers(input);
// Очікуємо: [2, 4, 6, 8]
// Отримуємо: [2, 6] (половина пропущена!)

Резюме

У цьому розділі ви освоїли фундаментальні техніки відлагодження C# коду:

Наступні Кроки

Тепер, коли ви володієте базовими техніками відлагодження, ви готові:

• Працювати з виключеннями: Налаштування Exception Settings для перехоплення помилок
• Профілювати код: Використання Performance Profiler для оптимізації
• Відлагоджувати асинхронний код: Особливості роботи з async/await
• Використовувати IntelliTrace: Історичне відлагодження (Visual Studio Enterprise)

Продовжуйте практикуватися, і debugging стане вашою суперсилою! 🚀