В чем преимущество использования фильтров исключений и когда их следует использовать?

Я не понимаю ответа Пауло. Он может быть прав, а может и нет.

Я определенно не согласен с ответом Александра. Это не просто синтаксический сахар. Чистый синтаксический сахар означает, что это просто более простой способ написать что-то, и это исполнение не изменится.

Однако в данной ситуации это не так. Как отмечает Томас Левеск в своем блоге , фильтры исключений не раскручивают стек. Таким образом, при отладке программы, если у вас возникло исключение в блоке try, с помощью фильтров исключений вы сможете увидеть, в каком состоянии находятся значения в блоке try. Если бы вы не использовали фильтры исключений, ваш код попал бы в блок catch, и вы бы потеряли информацию о состоянии переменных в блоке try.

Обратите внимание, что я не говорю о трассировке стека (это другое, но связанное со стеком понятие). Трассировка стека останется неизменной, если вы явно не повторите исключение, как в throw exception; в блоке перехвата, где exception — это пойманное исключение.

Поэтому, хотя в некоторых случаях вы можете думать об этом как о чем-то, что может сделать ваш код чище или нет (в зависимости от вашего мнения о синтаксисе), оно действительно меняет поведение.

Фильтры исключений были добавлены в C#, потому что они были в Visual Basic и команда "Roslyn" сочла их полезными при разработке "Roslyn".

Помните, что фильтр работает в контексте throw, а не в контексте catch.

Во всяком случае, одно использование может быть примерно таким:

try
{
    //...
}
catch (SqlException ex) when (ex.Number == 2)
{
    // ...
}
catch (SqlException ex)
{
    // ...
}

Отредактировано:

Можно подумать, что это просто синтаксический сахар:

try
{
    //...
}
catch (SqlException ex) when (ex.Number == 2)
{
    // ...
}
catch (SqlException ex)
{
   if (ex.Number == 2)
   {
       // ...
   }
   else
   {
       // ...
   }
}

Но если мы изменим код для этого:

try
{
    //...
}
catch (SqlException ex) when (ex.Number == 2)
{
    // ...
}

Это будет скорее так:

try
{
    //...
}
catch (SqlException ex) when (ex.Number == 2)
{
    // ...
}
catch (SqlException ex)
{
   if (ex.Number == 2)
   {
       // ...
   }
   else
   {
       throw
   }
}

Но есть одно принципиальное отличие. Исключение не перехватывается и не создается повторно, если ex.Number не равно 2. Он просто не пойман, если ex.Number не 2.

UPD: Как указано в ответе Пауло Моргадо, эта функция существует в CLR уже довольно давно, а в C# 6.0 для нее добавлена ​​только синтаксическая поддержка. Однако мое понимание этого остается синтаксическим сахаром, например. синтаксис, который позволяет мне фильтровать исключения более удобным способом, чем это было раньше, независимо от того, как работает предыдущий «прямой» метод под капотом.

=====

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

Рассмотрим следующий код:

try
{
    try
    {
        throw new ArgumentException() { Source = "One" };
        throw new ArgumentException() { Source = "Two" };
        throw new ArgumentException() { Source = "Three" };
    }
    catch (ArgumentException ex) when (ex.Source.StartsWith("One")) // local
    {
        Console.WriteLine("This error is handled locally");
    }
    catch (ArgumentException ex) when (ex.Source.StartsWith("Two")) // separate
    {
        Console.WriteLine("This error is handled locally");
    }

}
catch (ArgumentException ex) // global all-catcher
{
    Console.WriteLine("This error is handled globally");
}

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

    catch (ArgumentException ex)  // local
    {
                    if  (ex.Source.StartsWith("One")) 
                    {
                        Console.WriteLine("This error is handled locally");
                    } 
                    else 
                    {
                         throw;
                    }

    }