1. Использование исключений — затратно. не так, как SEH, но затратно.[/*]
   
2. Тем не менее, кидать исключение — Design-by-default для .Net{/*]

using System;
using System.Diagnostics;

public class Program
{
    static void Main()
    {
        const int Count = 100 * 1000;

        Measure("Fast, callstack  0", () => 
        {
            for (int i = 0; i < Count; i++)
            {
                TryCallMeFast(0);
            }
            return Count;
        });
        Measure("Exc,  callstack  0", () => 
        {
            for (int i = 0; i < Count; i++)
            {
                TryCallMeExc(0);
            }
            return Count;
        });
        Measure("Fast, callstack  1", () => 
        {
            for (int i = 0; i < Count; i++)
            {
                TryCallMeFast(1);
            }
            return Count;
        });
        Measure("Exc,  callstack  1", () => 
        {
            for (int i = 0; i < Count; i++)
            {
                TryCallMeExc(1);
            }
            return Count;
        }); 
        Measure("Fast, callstack 10", () => 
        {
            for (int i = 0; i < Count; i++)
            {
                TryCallMeFast(10);
            }
            return Count;
        });
        Measure("Exc,  callstack 10", () => 
        {
            for (int i = 0; i < Count; i++)
            {
                TryCallMeExc(10);
            }
            return Count;
        });
        Measure("Fast, callstack 20", () => 
        {
            for (int i = 0; i < Count; i++)
            {
                TryCallMeFast(20);
            }
            return Count;
        });
        Measure("Exc,  callstack 20", () => 
        {
            for (int i = 0; i < Count; i++)
            {
                TryCallMeExc(20);
            }
            return Count;
        });
        Console.Write("Done.");
        Console.ReadKey();
    }
    static bool TryCallMeFast(int count)
    {
        return TryCallMeCore(count, false);
    }
    static bool TryCallMeExc(int count)
    {
        try
        {
            return TryCallMeCore(count, true);
        }
        catch
        {
            return false;
        }
    }

    const int CatchEvery = 5;
    static bool TryCallMeCore(int count, bool fail)
    {
        if (count < 0) throw new ArgumentOutOfRangeException("Dont be kiddy.");
        if (count == 0)
        {
            if (fail) throw new InvalidOperationException("As you wish.");

            return false;
        }

        if (count % CatchEvery == 1)
        {
            try
            {
                return TryCallMeCore(count - 1, fail);
            }
            catch
            {
                throw;
            }
        }
        else
        {
            return TryCallMeCore(count - 1, fail);
        }
    }

    static void Measure(string name, Func<long> callback)
    {
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();

        var sw = Stopwatch.StartNew();
        var tmp = callback();
        sw.Stop();

        Console.WriteLine("{0,30}: {1,5}ms, ips: {2,16:F4} : {3,9}", name, sw.ElapsedMilliseconds, tmp / sw.Elapsed.TotalSeconds, tmp);
    }
}

Do not use exceptions for normal flow of control. Except for system failures, there should generally be a way to write code that avoids exceptions being thrown.

• Выбросить исключение в коде буфера и обработать во внешнем коде
  
• Всякий раз при добавлении элемента проверять есть ли в буфере место

            Fast, callstack  0:     0ms, ips:   247341083,3539 :    100000
            Exc,  callstack  0:  1529ms, ips:       65377,9624 :    100000
            Fast, callstack  1:     1ms, ips:    98941327,7926 :    100000
            Exc,  callstack  1:  2898ms, ips:       34504,8774 :    100000
            Fast, callstack 10:     6ms, ips:    14998350,1815 :    100000
            Exc,  callstack 10:  4720ms, ips:       21184,1113 :    100000
            Fast, callstack 20:    15ms, ips:     6335328,9620 :    100000
            Exc,  callstack 20:  7975ms, ips:       12537,7996 :    100000
Done.

            Fast, callstack  0:     0ms, ips:   154273372,4159 :    100000
            Exc,  callstack  0:  1075ms, ips:       92969,2299 :    100000
            Fast, callstack  1:     1ms, ips:    88707531,2694 :    100000
            Exc,  callstack  1:  2091ms, ips:       47807,8751 :    100000
            Fast, callstack 10:     4ms, ips:    22799297,7816 :    100000
            Exc,  callstack 10:  3148ms, ips:       31761,4567 :    100000
            Fast, callstack 20:     8ms, ips:    11827041,3473 :    100000
            Exc,  callstack 20:  5276ms, ips:       18953,0922 :    100000
Done.

testCppExceptions.exe!main$fin$0()
msvcr120d.dll!__C_specific_handler()
ntdll.dll!RtlpExecuteHandlerForUnwind()
ntdll.dll!RtlUnwindEx()
msvcr120d.dll!__C_specific_handler()
ntdll.dll!RtlpExecuteHandlerForException()
ntdll.dll!RtlDispatchException()
ntdll.dll!KiUserExceptionDispatch()
KernelBase.dll!RaiseException()
msvcr120d.dll!_CxxThrowException()
testCppExceptions.exe!main(int argc, char * * argv)

S>>            Exc,  callstack  0:  1529ms, ips:       65377,9624 :    100000
S>>            Exc,  callstack  1:  2898ms, ips:       34504,8774 :    100000

        if (count % CatchEvery == 1)
        {
            try
            {
                return TryCallMeCore(count - 1, fail);
            }
            catch
            {
                throw;
            }
        }
        else
        {
            return TryCallMeCore(count - 1, fail);
        }

  if (count % CatchEvery == 1) ...

            Fast, callstack  0:     0ms, ips:   191607587,6605 :    100000
            Exc,  callstack  0:  1243ms, ips:       80403,9236 :    100000
            Fast, callstack  1:     0ms, ips:   201045436,2686 :    100000
            Exc,  callstack  1:  1286ms, ips:       77722,6396 :    100000
            Fast, callstack 10:     2ms, ips:    37467216,1858 :    100000
            Exc,  callstack 10:  1766ms, ips:       56604,2755 :    100000
            Fast, callstack 20:     6ms, ips:    14556888,3196 :    100000
            Exc,  callstack 20:  2231ms, ips:       44822,7042 :    100000
Done.

            Fast, callstack  0:     0ms, ips:   181356546,9713 :    100000
            Exc,  callstack  0:   942ms, ips:      106153,9572 :    100000
            Fast, callstack  1:     0ms, ips:   100421771,4400 :    100000
            Exc,  callstack  1:  1924ms, ips:       51962,0912 :    100000
            Fast, callstack 10:     3ms, ips:    25368477,1303 :    100000
            Exc,  callstack 10:  2910ms, ips:       34353,4050 :    100000
            Fast, callstack 20:     7ms, ips:    13422638,6223 :    100000
            Exc,  callstack 20:  4910ms, ips:       20364,2044 :    100000
Done.

Do not use exceptions for normal flow of control. Except for system failures, there should generally be a way to write code that avoids exceptions being thrown.

            Fast, callstack  0:     0ms, ips:   247341083,3539 :    100000
            Exc,  callstack  0:  1529ms, ips:       65377,9624 :    100000
            Fast, callstack  1:     1ms, ips:    98941327,7926 :    100000
            Exc,  callstack  1:  2898ms, ips:       34504,8774 :    100000
            Fast, callstack 10:     6ms, ips:    14998350,1815 :    100000
            Exc,  callstack 10:  4720ms, ips:       21184,1113 :    100000
            Fast, callstack 20:    15ms, ips:     6335328,9620 :    100000
            Exc,  callstack 20:  7975ms, ips:       12537,7996 :    100000
Done.

А всё просто: исключения в дотнете заточены под исключительные ситуации (сорри за фиговый каламбур). Если производительность утыкается в стоимость обработки исключений, то проблема уже на 100% не в них самих, а в непродуманной архитектуре / незнании матчасти / неправильно написанном API и тд и тп. Исключений из этого правила на практике не видел.

Ну и разумеется в крайности не надо впадать. Исключения отлично работают для отмены/отката бизнес-операций (кучу понятных оговорок про необходимость отката состояния, побочные эффекты и тд и тп пропустим). А вот писать try-catch вокруг метода проверки заказа — это уже перебор

В общем после прочтения указанных ссылок я сделал вывод, что если речь идет о производительности, то использования исключений нужно избегать. А в остальных случаях все зависит от ситуации.

Решать надо не со стороны производительности, а со стороны того, что лучше подходит — исключение или дополнительная проверка

MC>А я где-то рекомендовал использовать исключения "for normal flow of control"?

cache.TryGet(objKey, out obj);
obj.DoSomething();

Cynic:
Например возьмём такой пример: Есть у меня есть некий буфер, который может периодически переполняться и переполнение нужно как-то обрабатывать. Я могу решить эту проблему двумя путями:
Выбросить исключение в коде буфера и обработать во внешнем коде
Всякий раз при добавлении элемента проверять есть ли в буфере место
При этом операции записи в буфер происходят довольно часто. Правильно ли я понимаю, что в данном случае лучше избегать исключений?