Что происходит со stack во время обработки метода в C#?

Что происходит со stack во время обработки метода в C#?

Call stack (стек вызовов) — это критическая структура памяти в C# и других языков программирования. Понимание его работы важно для отладки и оптимизации.

Основная концепция

Stack — это память, которая работает по принципу LIFO (Last-In-First-Out). При вызове метода в стек добавляется новый frame (кадр), при возврате из метода — frame удаляется.

Пошаговый пример

public class Program {
    static void Main() {
        int result = Add(5, 3);  // Вызов метода Add
        Console.WriteLine(result);
    }
    
    static int Add(int a, int b) {
        int sum = a + b;  // Локальная переменная
        return sum;
    }
}

Что происходит в памяти:

1. Запуск Main()

   Stack:
   [Main frame]
       result = ?
   

2. Вызов Add(5, 3)

   Stack:
   [Add frame]  <- Новый frame добавлен
       a = 5
       b = 3
       sum = ?
   [Main frame]
       result = ?
   

3. sum = a + b

   Stack:
   [Add frame]
       a = 5
       b = 3
       sum = 8
   [Main frame]
       result = ?
   

4. return sum

   Stack:
   [Main frame]  <- Add frame удален из стека
       result = 8
   

Что входит в Stack Frame?

При вызове метода в stack добавляется frame, содержащий:

1. Параметры метода (a, b)
2. Локальные переменные (sum)
3. Return address — адрес, куда вернуться после метода
4. Previous frame pointer — ссылка на предыдущий frame

static int Multiply(int x, int y) {
    int result = x * y;
    int doubled = result * 2;
    
    // Stack frame содержит:
    // - x (параметр)
    // - y (параметр)
    // - result (локальная)
    // - doubled (локальная)
    // - return address (куда вернуться)
    
    return doubled;
}

Различие между Value Types и Reference Types

Value Types (int, struct) — хранятся в stack:

static void Main() {
    int x = 10;  // x в stack
    MyStruct s = new MyStruct();  // s в stack
}

struct MyStruct {
    public int Value;
}

Reference Types (class, string) — ссылка в stack, данные в heap:

static void Main() {
    MyClass obj = new MyClass();  // obj (ссылка) в stack
                                   // новый объект в heap
}

class MyClass {
    public int Value;
}

Stack vs Heap

StackOverflowException

Когда stack переполняется:

// Бесконечная рекурсия
static void Infinite() {
    Infinite();  // Вызывает себя
    // Каждый вызов добавляет frame в stack
    // Скоро stack переполнится!
}

static void Main() {
    Infinite();  // StackOverflowException
}

Почему происходит:

Вызов 1: [Infinite-1] <- stack
Вызов 2: [Infinite-2][Infinite-1] <- stack
Вызов 3: [Infinite-3][Infinite-2][Infinite-1] <- stack
...
Stack переполнен -> StackOverflowException

Правильная рекурсия

static int Factorial(int n) {
    if (n <= 1)  // Base case - выход из рекурсии
        return 1;
    
    // Рекурсивный вызов
    return n * Factorial(n - 1);
}

static void Main() {
    int result = Factorial(5);  // ОК: 5 вложенных вызовов
    int huge = Factorial(100000);  // StackOverflow: слишком глубоко
}

Пример с методами, вызывающими друг друга

static void Method1() {
    Console.WriteLine("1");
    Method2();
}

static void Method2() {
    Console.WriteLine("2");
    Method3();
}

static void Method3() {
    Console.WriteLine("3");
}

static void Main() {
    Method1();
}

// Stack при вызове:
// Шаг 1: [Main]
// Шаг 2: [Method1][Main]
// Шаг 3: [Method2][Method1][Main]
// Шаг 4: [Method3][Method2][Method1][Main]
// Шаг 5: [Method2][Method1][Main]  (Method3 завершилась)
// Шаг 6: [Method1][Main]           (Method2 завершилась)
// Шаг 7: [Main]                    (Method1 завершилась)

Optimization: Tail Recursion

Некоторые компиляторы (не C# по умолчанию) оптимизируют tail recursion:

// Tail recursion (C# не оптимизирует по умолчанию)
static int FactorialTail(int n, int acc = 1) {
    if (n <= 1)
        return acc;
    return FactorialTail(n - 1, acc * n);  // Tail call
}

// Это можно переписать как loop (эффективнее)
static int FactorialLoop(int n) {
    int result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

Stack Trace для отладки

При исключении C# показывает stack trace:

Unhandled Exception: System.NullReferenceException
   at MyApp.Method3() in Program.cs:line 25
   at MyApp.Method2() in Program.cs:line 20
   at MyApp.Method1() in Program.cs:line 15
   at MyApp.Main() in Program.cs:line 10

Это показывает точный путь вызовов в момент ошибки.

Практические рекомендации

1. Избегай глубокой рекурсии — используй loops вместо recursion
2. Помни о StackOverflow — особенно при работе с большими структурами
3. Value types против classes — value types экономят heap память
4. Локальные переменные автоматически чистятся — когда method завершается

Stack — это elegantly простая, но мощная структура, которая управляет выполнением программы.