To artykuł w MSDN stwierdza, że ​​możesz użyć tylu bloków prób, ile chcesz, i nie ponosić żadnych kosztów wydajności, dopóki nie zostanie zgłoszony żaden wyjątek.
Ponieważ zawsze wierzyłem, że próba przechwycenia zawsze wymaga niewielkiego trafienia wydajności, nawet jeśli nie rzucam wyjątku, zrobiłem mały test.

 private void TryCatchPerformance()
        {
            int iterations = 100000000;

            Stopwatch stopwatch = Stopwatch.StartNew();
            int c = 0;
            for (int i = 0; i < iterations; i++)
            {
                try
                {
                   // c += i * (2 * (int)Math.Floor((double)i));
                    c += i * 2;
                }
                catch (Exception ex)
                {
                    throw;
                }
            }
            stopwatch.Stop();
            WriteLog(String.Format("With try catch: {0}", stopwatch.ElapsedMilliseconds));

            Stopwatch stopwatch2 = Stopwatch.StartNew();
            int c2 = 0;
            for (int i = 0; i < iterations; i++)
            {
              //  c2 += i * (2 * (int)Math.Floor((double)i));
                c2 += i * 2;
            }
            stopwatch2.Stop();
            WriteLog(String.Format("Without try catch: {0}", stopwatch2.ElapsedMilliseconds));
        }

Wyjście, które otrzymuję:

With try catch: 68
Without try catch: 34

Wygląda więc na to, że użycie bloku try-catch nie wydaje się być szybsze?

Jeszcze bardziej dziwne jest to, że kiedy zamieniam obliczenia w treści pętli for przez coś bardziej złożonego, takiego jak:c += i * (2 * (int)Math.Floor((double)i));
Różnica jest znacznie mniej dramatyczna.

With try catch: 640
Without try catch: 655

Czy robię tu coś złego, czy jest to logiczne wyjaśnienie?