Warum kann sich eine 'continue'-Anweisung nicht in einem' finally'-Block befinden?

Ich habe kein Problem; Ich bin nur Neugierig. Stellen Sie sich folgendes Szenario vor:

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

Dies wird nicht kompiliert, da es den Compilerfehler CS0157 auslöst :

Die Kontrolle kann den Text einer finally-Klausel nicht verlassen

Warum?

finallyBlöcke werden ausgeführt, unabhängig davon, ob eine Ausnahme ausgelöst wird oder nicht. Was zum Teufel würde continuetun, wenn eine Ausnahme ausgelöst wird ? Sie können die Ausführung der Schleife nicht fortsetzen, da eine nicht erfasste Ausnahme die Steuerung an eine andere Funktion überträgt.

Selbst wenn keine Ausnahme ausgelöst wird, finallywird sie ausgeführt, wenn andere Steuerungsübertragungsanweisungen innerhalb des try / catch-Blocks ausgeführt werden return, z. B. a, was das gleiche Problem mit sich bringt.

Kurz gesagt, mit der Semantik macht finallyes keinen Sinn, die Kontrolle von innerhalb eines finallyBlocks nach außen zu übertragen.

Dies mit einer alternativen Semantik zu unterstützen, wäre eher verwirrend als hilfreich, da es einfache Problemumgehungen gibt, die das beabsichtigte Verhalten klarer machen. Sie erhalten also einen Fehler und müssen über Ihr Problem richtig nachdenken. Es ist die allgemeine Idee "Wirf dich in die Grube des Erfolgs", die in C # weitergeht.

Wenn Sie Ausnahmen ignorieren möchten (meistens ist dies eine schlechte Idee) und die Schleife weiter ausführen möchten, verwenden Sie einen catch all-Block:

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

Wenn Sie continuenur dann möchten, wenn keine nicht erfassten Ausnahmen ausgelöst werden, setzen Sie sie einfach continueaußerhalb des Try-Blocks.

Hier ist eine zuverlässige Quelle:

Eine continue-Anweisung kann einen finally-Block nicht beenden (Abschnitt 8.10). Wenn eine continue-Anweisung innerhalb eines finally-Blocks auftritt, muss sich das Ziel der continue-Anweisung innerhalb desselben finally-Blocks befinden. Andernfalls tritt ein Fehler bei der Kompilierung auf.

Es stammt aus MSDN, 8.9.2 Die continue-Anweisung .

Die Dokumentation sagt, dass:

Die Anweisungen eines finally-Blocks werden immer ausgeführt, wenn die Steuerung eine try-Anweisung hinterlässt. Dies gilt unabhängig davon, ob die Steuerungsübertragung als Ergebnis einer normalen Ausführung, als Ergebnis der Ausführung einer Anweisung break, continue, goto oder return oder als Ergebnis der Weitergabe einer Ausnahme aus der try-Anweisung erfolgt. Wenn während der Ausführung eines finally-Blocks eine Ausnahme ausgelöst wird, wird die Ausnahme an die nächste umschließende try-Anweisung weitergegeben. Wenn eine andere Ausnahme gerade weitergegeben wird, geht diese Ausnahme verloren. Der Prozess der Weitergabe einer Ausnahme wird in der Beschreibung der throw-Anweisung (Abschnitt 8.9.5) näher erläutert.

Es ist von hier 8.10 Die try-Anweisung .

Sie mögen denken, dass es Sinn macht, aber es macht eigentlich keinen Sinn .

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

Was beabsichtigen Sie, eine Pause einzulegen oder fortzufahren, wenn eine Ausnahme ausgelöst wird? Das C # -Compilerteam möchte keine eigene Entscheidung treffen, indem es breakoder annimmt continue. Stattdessen beschlossen sie, sich darüber zu beschweren, dass die Entwicklersituation nicht eindeutig ist, um die Kontrolle zu übertragen finally block.

Es ist also die Aufgabe des Entwicklers, klar anzugeben, was er vorhat, anstatt dass der Compiler etwas anderes annimmt.

Ich hoffe du verstehst warum das nicht kompiliert wird!

Wie andere gesagt haben, sich aber auf Ausnahmen konzentrieren, geht es wirklich um die mehrdeutige Behandlung der Übertragung von Kontrolle.

In Ihrem Kopf denken Sie wahrscheinlich an ein Szenario wie dieses:

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;
}

Theoretisch können Sie den Kontrollfluss verfolgen und sagen, ja, das ist "ok". Es wird keine Ausnahme ausgelöst, keine Kontrolle übertragen. Die C # -Sprachendesigner hatten jedoch andere Probleme.

Die geworfene Ausnahme

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

Der gefürchtete Goto

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

    pigsfly:
}

Die Rückkehr

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

Die Trennung

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

Zusammenfassend lässt sich sagen, dass es zwar eine geringfügige Möglichkeit gibt, a continuein Situationen zu verwenden, in denen die Kontrolle nicht übertragen wird, aber in vielen Fällen (Mehrheit?) Ausnahmen oder returnBlockierungen auftreten. Die Sprachdesigner waren der Meinung, dass dies zu vieldeutig und (wahrscheinlich) unmöglich wäre, um bei der Kompilierung sicherzustellen, dass Ihre continueverwendet wird nur in Fällen , in denen der Kontrollfluss nicht übertragen wird.

Im Allgemeinen continuemacht es keinen Sinn, wenn es im finallyBlock verwendet wird. Schau dir das an:

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

"Das wird nicht kompiliert und ich denke, es macht durchaus Sinn."

Nun, ich denke nicht.

Wenn Sie buchstäblich haben, catch(Exception)dann brauchen Sie nicht das endgültige (und wahrscheinlich nicht einmal das continue).

catch(SomeException)Was sollte passieren, wenn eine Ausnahme nicht abgefangen wird, wenn Sie realistischer sind? Sie continuemöchten einen Weg gehen, die Ausnahme einen anderen.

Sie können den Körper eines endgültigen Blocks nicht verlassen. Dies umfasst die Schlüsselwörter break, return und in Ihrem Fall continue.

Der finallyBlock kann mit einer Ausnahme ausgeführt werden, die darauf wartet, erneut ausgelöst zu werden. Es wäre nicht wirklich sinnvoll, den Block verlassen zu können (durch acontinue oder irgendetwas anderes) verlassen zu können, ohne die Ausnahme erneut auszulösen.

Wenn Sie Ihre Schleife fortsetzen möchten, brauchen Sie nicht die finally-Anweisung: Fangen Sie einfach die Ausnahme ab und werfen Sie sie nicht erneut.

finallyLäuft, ob eine nicht erfasste Ausnahme ausgelöst wird oder nicht. Andere haben bereits erklärt, warum dies continueunlogisch ist, aber hier ist eine Alternative, die dem Geist dessen folgt, wonach dieser Code zu fragen scheint. Grundsätzlich finally { continue; }heißt es:

1. Wenn es Ausnahmen gibt, fahren Sie fort
2. Wenn es nicht erfasste Ausnahmen gibt, lassen Sie sie werfen, aber fahren Sie fort

(1) könnte durch Platzieren continueam Ende eines jeden erfüllt werden catch, und (2) könnte durch Speichern nicht erfasster Ausnahmen, die später geworfen werden sollen, befriedigt werden. Sie könnten es so schreiben:

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);
}

Eigentlich finallyhätte auch im dritten Fall ausgeführt, wo es überhaupt keine Ausnahmen gab, gefangen oder nicht gefangen. Wenn das gewünscht wäre, könnten Sie natürlich einfach einen einzelnen continuenach dem Try-Catch-Block platzieren, anstatt in jedem catch.

Technisch gesehen ist dies eine Einschränkung der zugrunde liegenden CIL. Aus der Sprachspezifikation :

Die Steuerübertragung darf nur über den Ausnahmebehandlungsmechanismus in einen Catch-Handler oder eine finally-Klausel eingegeben werden.

und

Steuertransfer aus einem geschützten Bereich ist nur durch eine Ausnahmebefehl erlaubt ( leave, end.filter, end.catch, oder end.finally)

Auf der Dokumentseite für die brAnweisung :

Steuerungsübertragungen in und aus Try-, Catch-, Filter- und schließlich-Blöcken können mit dieser Anweisung nicht ausgeführt werden.

Dieser letzte gilt für wahr alle Zweigbefehle, einschließlich beq, brfalseusw.

Die Designer der Sprache wollten (oder konnten) einfach nicht begründen, dass die Semantik eines endgültigen Blocks durch eine Steuerungsübertragung beendet wird.

Ein Problem oder vielleicht das Hauptproblem ist, dass die finally Block als Teil einer nicht lokalen Steuerübertragung (Ausnahmeverarbeitung) ausgeführt wird. Das Ziel dieser Steuerübertragung ist nicht die umschließende Schleife. Die Ausnahmeverarbeitung bricht die Schleife ab und wickelt sich weiter ab.

Wenn wir eine Kontrollübertragung aus dem haben finally Bereinigungsblock haben, wird die ursprüngliche Kontrollübertragung "entführt". Es wird abgebrochen und die Kontrolle geht woanders hin.

Die Semantik kann ausgearbeitet werden. Andere Sprachen haben es.

Die Designer von C # haben beschlossen, statische, "goto-ähnliche" Steuerübertragungen einfach nicht zuzulassen, wodurch die Dinge etwas vereinfacht wurden.

Selbst wenn Sie dies tun, wird die Frage, was passiert, wenn eine dynamische Übertragung von a initiiert wird, nicht gelöst finally : Was wenn der finally-Block eine Funktion aufruft und diese Funktion auslöst? Die ursprüngliche Ausnahmeverarbeitung wird dann "entführt".

Wenn Sie die Semantik dieser zweiten Form der Entführung herausarbeiten, gibt es keinen Grund, den ersten Typ zu verbannen. Sie sind wirklich dasselbe: Eine Kontrollübertragung ist eine Kontrollübertragung, unabhängig davon, ob sie denselben lexikalischen Umfang hat oder nicht.