Почему try-catch ускоряет выполнение моего кода на C#?

Это не try-catch ускоряет код — это JIT-компилятор меняет оптимизации

Вы столкнулись с классическим эффектом, который хорошо известен в .NET сообществе. На самом деле, try-catch не ускоряет выполнение кода. Проблема в том, что присутствие блока try-catch влияет на решения, которые принимает JIT-компилятор (Just-In-Time compiler) при генерации машинного кода.

Основная причина — инлайнинг (встраивание) границ проверок

JIT-компилятор в .NET (особенно RyuJIT в .NET Core/.NET 5+) ведет себя по-разному в зависимости от наличия блоков обработки исключений. В вашем случае происходит следующее:

• Без try-catch: JIT может применить более агрессивные оптимизации, включая встраивание границ проверки массива. Это может привести к тому, что код станет чувствительным к выравниванию инструкций в памяти. Иногда такое выравнивание оказывается неоптимальным, и процессор тратит лишние такты на загрузку команд.
• С try-catch: JIT ведет себя консервативнее. Он не встраивает границы проверок так агрессивно, что приводит к другому расположению инструкций. Случайно это расположение оказывается более удачным для кэша инструкций процессора. Код выполняется быстрее не из-за try-catch, а вопреки ему.

Демонстрация эффекта

Давайте напишем тест, который показывает, что дело именно в расположении кода, а не в самом try-catch. Добавим пустой блок if (false), который никогда не выполняется:

public static void ProcessWithFakeCondition(int[] data)
{
    for (int i = 0; i < data.Length; i++)
    {
        if (false) // Этот блок никогда не выполняется
        {
            int x = 0;
        }
        
        if (data[i] > 0 && data[i] < 100)
        {
            int result = data[i] * 2;
        }
    }
}

Вы с удивлением обнаружите, что этот вариант тоже может работать быстрее оригинального. Почему? Потому что JIT сгенерировал другой набор инструкций, и они лучше легли в кэш.

Правильный способ измерения производительности

Чтобы избежать таких артефактов, используйте BenchmarkDotNet — стандартный инструмент для бенчмаркинга в .NET. Он учитывает:

• Прогрев JIT (Warmup)
• Эффекты кэширования
• Статистическую значимость результатов

[SimpleJob(RuntimeMoniker.Net60)]
public class MyBenchmark
{
    private int[] _data;

    [GlobalSetup]
    public void Setup()
    {
        _data = new int[10_000_000];
        var rnd = new Random(42);
        for (int i = 0; i < _data.Length; i++)
            _data[i] = rnd.Next(0, 200);
    }

    [Benchmark]
    public void WithoutTryCatch() => ProcessWithoutTryCatch(_data);

    [Benchmark]
    public void WithTryCatch() => ProcessWithTryCatch(_data);
}

Вывод

Не пытайтесь использовать try-catch для оптимизации. Это случайный побочный эффект, который может исчезнуть при смене версии .NET, архитектуры процессора или размера данных. Если вам кажется, что try-catch ускоряет код — это признак того, что ваши измерения некорректны. Используйте BenchmarkDotNet для надежных тестов.

P.S. В реальном коде пустой catch — это антипаттерн. Он скрывает реальные ошибки и делает код непредсказуемым.

// Добавим NOP-инструкции для сдвига кода
public static void ProcessWithNops(int[] data)
{
    // 10 пустых операций для сдвига
    System.Runtime.CompilerServices.RuntimeHelpers.PrepareMethod(
        typeof(Program).GetMethod("ProcessWithNops").MethodHandle);
    
    for (int i = 0; i < data.Length; i++)
    {
        if (data[i] > 0 && data[i] < 100)
        {
            int result = data[i] * 2;
        }
    }
}