Почему оператор continue не может находиться внутри блока finally?

У меня нет проблем; Мне просто любопытно. Представьте себе следующий сценарий:

foreach (var foo in list)
{
    try
    {
         //Some code
    }
    catch (Exception)
    {
        //Some more code
    }
    finally
    {
        continue;
    }
}

Это не скомпилируется, поскольку вызывает ошибку компилятора CS0157 :

Контроль не может покинуть тело предложения finally

Зачем?

finallyблоки выполняются вне зависимости от того, выброшено ли исключение. Если возникнет исключение, что, черт возьми, будет continueделать? Вы не можете продолжить выполнение цикла, потому что неперехваченное исключение передаст управление другой функции.

Даже если исключение не возникло, он finallyбудет запущен, когда будут выполняться другие операторы передачи управления внутри блока try / catch, например return, например, который вызывает ту же проблему.

Короче говоря, с семантикой finallyне имеет смысла разрешать передачу управления изнутри finallyблока за его пределы.

Поддержка этого с помощью некоторой альтернативной семантики была бы скорее запутанной, чем полезной, поскольку есть простые обходные пути, которые делают предполагаемое поведение более понятным. Таким образом, вы получаете сообщение об ошибке и вынуждены как следует задуматься над своей проблемой. Это общая идея «бросить вас в яму успеха», воплощенная в C #.

Если вы хотите игнорировать исключения (чаще всего это плохая идея) и продолжать выполнение цикла, используйте блок catch all:

foreach ( var in list )
{
    try{
        //some code
    }catch{
        continue;
    }
}

Если вы хотите делать это continueтолько тогда, когда не возникают неперехваченные исключения, просто поместите его continueза пределы блока try.

Вот надежный источник:

Оператор continue не может выйти из блока finally (раздел 8.10). Когда оператор continue встречается в блоке finally, цель оператора continue должна находиться в том же блоке finally; в противном случае возникает ошибка времени компиляции.

Это взято из MSDN, 8.9.2 Оператор continue .

В документации сказано, что:

Операторы блока finally всегда выполняются, когда элемент управления выходит из оператора try. Это верно независимо от того, происходит ли передача управления в результате нормального выполнения, в результате выполнения оператора break, continue, goto или return или в результате распространения исключения из оператора try. Если во время выполнения блока finally возникает исключение, исключение распространяется на следующий включающий оператор try. Если другое исключение находилось в процессе распространения, это исключение теряется. Процесс распространения исключения обсуждается далее в описании оператора throw (раздел 8.9.5).

Отсюда. 8.10 Оператор try .

Вы можете подумать, что это имеет смысл, но на самом деле это не имеет смысла .

foreach (var v in List)
{
    try
    {
        //Some code
    }
    catch (Exception)
    {
        //Some more code
        break; or return;
    }
    finally
    {
        continue;
    }
}

Что вы намереваетесь сделать паузу или продолжить при возникновении исключения? Команда компилятора C # не хочет принимать решение самостоятельно, предполагая breakили continue. Вместо этого они решили пожаловаться на то, что ситуация с разработчиком будет неоднозначной с передачей управления finally block.

Так что задача разработчика - четко указать, что он намерен делать, а не компилятор, предполагающий что-то еще.

Надеюсь, вы понимаете, почему это не компилируется!

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

Вы, вероятно, думаете о таком сценарии:

public static object SafeMethod()
{
    foreach(var item in list)
    {
        try
        {
            try
            {
                //do something that won't transfer control outside
            }
            catch
            {
                //catch everything to not throw exceptions
            }
        }
        finally
        {
            if (someCondition)
                //no exception will be thrown, 
                //so theoretically this could work
                continue;
        }
    }

    return someValue;
}

Теоретически вы можете отследить поток управления и сказать «да, это нормально». Исключение не создается, управление не передается. Но у разработчиков языка C # были другие проблемы.

Выброшенное исключение

public static void Exception()
{
    try
    {
        foreach(var item in list)
        {
            try
            {
                throw new Exception("What now?");
            }
            finally
            {
                continue;
            }
        }
    }
    catch
    {
        //do I get hit?
    }
}

Ужасный Гото

public static void Goto()
{
    foreach(var item in list)
    {
        try
        {
            goto pigsfly;
        }
        finally
        {
            continue;
        }
    }

    pigsfly:
}

Возврат

public static object ReturnSomething()
{
    foreach(var item in list)
    {
        try
        {
            return item;
        }
        finally
        {
            continue;
        }
    }
}

Расставание

public static void Break()
{
    foreach(var item in list)
    {
        try
        {
            break;
        }
        finally
        {
            continue;
        }
    }
}

Итак , в заключении, да, хотя это небольшая возможность использования continueв ситуациях , когда управление не передаются, но много (большинство?) Случаев включают исключение или returnблоки. Разработчики языка посчитали, что это будет слишком двусмысленно и (вероятно) невозможно гарантировать во время компиляции, что your continueиспользуется только в тех случаях, когда поток управления не передается.

Вообще continueне имеет смысла при finallyблочном использовании. Взгляните на это:

foreach (var item in list)
{
    try
    {
        throw new Exception();
    }
    finally{
        //doesn't make sense as we are after exception
        continue;
    }
}

"Это не компилируется, и я думаю, что это имеет смысл"

Думаю, нет.

Когда у вас буквально есть, catch(Exception)то вам не нужно последнее (и, вероятно, даже не continue).

Когда у вас есть более реалистичный catch(SomeException), что должно произойти, если исключение не обнаружено? Вы continueхотите идти одним путем, а исключение обрабатывает другое.

Вы не можете покинуть тело блока finally. Это включает ключевые слова break, return и, в вашем случае, continue.

finallyБлок может быть выполнен с исключением ждать , чтобы быть вызваны повторно. На самом деле было бы бессмысленно иметь возможность выйти из блока (с помощью a continueили чего-то еще) без повторной генерации исключения.

Если вы хотите продолжить цикл, что бы ни случилось, вам не нужен оператор finally: просто перехватите исключение и не вызывайте повторно.

finallyвыполняется независимо от того, выбрано ли неперехваченное исключение. Другие уже объяснили, почему это continueнелогично, но вот альтернатива, которая следует духу того, о чем, похоже, просит этот код. По сути, finally { continue; }это говорит:

1. Когда будут обнаружены исключения, продолжить
2. Если есть неперехваченные исключения, разрешите их выбросить, но продолжайте

(1) можно удовлетворить, поместив continueв конец каждого catch, а (2) можно удовлетворить, сохранив неперехваченные исключения, которые будут выброшены позже. Вы могли бы написать это так:

var exceptions = new List<Exception>();
foreach (var foo in list) {
    try {
        // some code
    } catch (InvalidOperationException ex) {
        // handle specific exception
        continue;
    } catch (Exception ex) {
        exceptions.Add(ex);
        continue;
    }
    // some more code
}
if (exceptions.Any()) {
    throw new AggregateException(exceptions);
}

Фактически, finallyон также был бы выполнен в третьем случае, где не было вообще никаких исключений, пойманных или неперехваченных. Если бы это было желательно, вы, конечно, могли бы просто разместить один continueпосле блока try-catch, а не внутри каждого catch.

Технически говоря, это ограничение основного CIL. Из спецификации языка :

Передаче управления никогда не разрешается вводить обработчик catch или предложение finally, кроме как через механизм обработки исключений.

и

Передача управления из защищенной области разрешается только через инструкцию исключения ( leave, end.filter, end.catchили end.finally)

На странице документации с brинструкциями :

Передача управления в блоки try, catch, filter и finally не может выполняться с помощью этой инструкции.

Последнее верно для всех инструкций ветвления, включая beq, brfalseи т. Д.

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

Одна проблема, или, возможно, ключевая проблема, заключается в том, что finallyблок выполняется как часть некоторой нелокальной передачи управления (обработка исключений). Целью этой передачи управления не является замыкающий цикл; обработка исключения прерывает цикл и продолжает разворачиваться дальше.

Если у нас есть передача управления из finallyблока очистки, то исходная передача управления «захватывается». Он отменяется, и контроль переходит в другое место.

Семантику можно проработать. Это есть на других языках.

Разработчики C # решили просто запретить статическую передачу элементов управления, подобную goto, тем самым несколько упростив ситуацию.

Однако даже если вы это сделаете, это не решит вопрос о том, что произойдет, если динамическая передача инициируется из a finally: что, если блок finally вызывает функцию, а эта функция вызывает? Затем исходная обработка исключений «перехватывается».

Если вы проработаете семантику этой второй формы угона, не будет никаких причин для исключения первого типа. На самом деле это одно и то же: передача управления - это передача управления, независимо от того, в той же лексической области или нет.