Fortsetzen der Ausführung von Code nach der Ausnahme wird ausgelöst und abgefangen

Wie ist es möglich, zum fortsetzen der Ausführung von code nach dem eine exception geworfen wird?

Nehmen wir zum Beispiel folgenden code:

namespace ConsoleApplication1
{
    public class Test
    {
        public void s()
        {
            throw new NotSupportedException();
            string @class = "" ;
            Console.WriteLine(@class);
            Console.ReadLine();
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            try
            {
                new Test().s();
            }
            catch (ArgumentException x)
            {
            }
            catch (Exception ex)
            {
            }
        }
    }
}

Nachdem die exception zu fangen, wenn Durchlaufen, das Programm wird beendet. Wie kann ich trotzdem auf der Ausführung?

EDIT: Was ich konkret meine, ist das line-Konsole.WriteLine(@class); scheint nicht getroffen zu werden, weil, wenn ich laufen, um es, wenn im debug-Modus, wird das Programm beendet den debug-Modus. Ich möchte laufen auf dieser Linie und stoppen.

Dank

InformationsquelleAutor der Frage dotnetdev | 2010-06-09

c#exception exception-handling

25

Gut, Sie müssen nicht jeden code nach der catch Blöcke, so würde das Programm nicht mehr ausgeführt werden. Nicht sicher, was Sie zu tun versuchen.

Folgenden sollte der Nachweis, dass das Programm nicht einfach "beenden", nachdem die catch Blöcke. Es wird das ausführen von code nach der catch blockiert werden, wenn der code ausgeführt werden soll:
```
static void Main(string[] args)
{
    try
    {
        new Test().s();
    }
    catch (ArgumentException x)
    {
        Console.WriteLine("ArgumentException caught!");
    }
    catch (Exception ex) 
    { 
        Console.WriteLine("Exception caught!");
    }

    Console.WriteLine("I am some code that's running after the exception!");
}
```
Wird der code drucken Sie die entsprechende Zeichenfolge abhängig von der Ausnahme, die gefangen wurde. Dann, es wird gedruckt I am some code that's running after the exception! am Ende.

UPDATE

In Ihren Bearbeiten Sie fragte, warum Console.WriteLine(@class); scheint nicht getroffen zu werden. Der Grund dafür ist, dass Sie explizit das werfen einer exception in die erste Zeile der s() Methode; alles, was folgt, wird ignoriert. Wenn eine Ausnahme Auftritt, wird die Ausführung beendet und die Ausnahme weitergegeben, bis der call stack bis die entsprechenden handler verarbeiten kann (dies kann eine catch - block, entspricht der try umschließt, die Aussage in Frage, die innerhalb der gleichen Methode, oder es kann eine catch block weiter oben in der Aufruf-stack. Sollte kein passender handler gefunden wird, wird das Programm beendet mit einem stacktrace [zumindest in Java - nicht sicher, ob das gleiche passiert in C#]).

Wenn Sie wollen zu treffen, die Console.WriteLine Linie, dann sollten Sie nicht explizit eine Ausnahme an den Anfang der Methode.

InformationsquelleAutor der Antwort Vivin Paliath

Wenn Sie besorgt sind, dass eine Ausnahme geworfen wird, in der Methode, aber Sie wollen, dass die Methode weiter, fügen Sie eine Fehlerbehandlung innerhalb der Methode.

class Test 
{ 
    public void s() 
    { 
        try
          {
              //Code that may throw an exception
              throw new NotSupportedException();
          } 
          catch(Exception ex)
          {
              //Handle the exception - log?, reset some values?
          }
          string @class = "" ; 
          Console.WriteLine(@class); 
          Console.ReadLine(); 
    } 
}

Könnte man auch wieder ein boolescher Wert oder einen anderen Wert angeben, der Staat.

InformationsquelleAutor der Antwort Patrick

5

Klingt es wie Sie wollen, sind resumeable Ausnahmen. C# nicht resumeable Ausnahmen, und ich bin zweifelhaft, dass die CLR unterstützt.

Den Zweck, das werfen einer exception zum Abbruch einer Funktion und einer gesamten Betrieb (call stack), wenn etwas in der call-Umgebung (Parameter, object state, globaler Status), macht die Funktion " Betrieb unmöglich oder ungültig. Übergabe einer null-param auf eine Funktion, die Bedürfnisse zu teilen eine Menge durch, param, zum Beispiel. Die Division durch null nicht produzieren zu einem aussagekräftigen Ergebnis, und wenn das der einzige Zweck der Funktion, dann ist die Funktion nicht mehr zurück können, ein sinnvolles Ergebnis. Also, eine exception zu werfen. Dies wird verursacht, dass die Ausführung zu springen, um die nächste catch-oder finally-block in der Aufrufliste. Es gibt keine Rückkehr zu der Funktion, die die Ausnahme ausgelöst hat.

Wenn Sie wollen, um den Schritt in den code im debugger zu verfolgen, die Konsole.WriteLine () - aufrufen, müssen Sie entfernen Sie die throw new NotSupportedException () - Zeile aus der code und kompilieren Sie neu.

InformationsquelleAutor der Antwort dthorpe

Disclaimer: ich behaupte nicht, dass Sie wirklich tun.

Kann man nach der alten VB-style " On Error Resume Next durch den folgenden code.

public static class ControlFlow
{
  public static Exception ResumeOnError(Action action)
  {
    try
    {
      action();
      return null;
    }
    catch (Exception caught)
    { 
      return caught;
    }
  }
}

Und dann könnte es wie folgt benutzt werden.

public static void Main()
{
  ControlFlow.ResumeOnError(() => { throw new NotSupportedException(); });
  ControlFlow.ResumeOnError(() => { Console.WriteLine(); });
  ControlFlow.ResumeOnError(() => { Console.ReadLine(); });
}

InformationsquelleAutor der Antwort Brian Gideon

0

Ausführung ist noch carying, aber es ist kein code nach der die Ausnahme abgefangen ist. Wenn Sie wollen, um immer wieder call s dann wrappen wenn die try/catch-block in einer while-Schleife.

InformationsquelleAutor der Antwort JB King
0

Wird das Programm nicht ausgeführt werden, weil es keine folgenden code, der ausgeführt werden soll in der Main () - Methode! Sie können fügen Sie die folgende Zeile, um Ihren code zu halten das Programm läuft, bis es eine console input:
```
Console.ReadLine();
```
InformationsquelleAutor der Antwort Marius Schulz
0

Für diesen code, kann man nicht. Wenn Sie brechen die Aufgaben in kleinere Stücke, Sie können Sie fortsetzen, in den nächsten chunk. Aber normalerweise ist es einfacher, einen anderen Mechanismus als Ausnahmen zu melden, die nicht-fatale Fehler, wie eine callback-Funktion, die zurückgibt, ob oder nicht, um fortzufahren.

InformationsquelleAutor der Antwort Pete Kirkham
0

Können Sie die "step-over" - Funktion im debugging zu erreichen, das auf einer pro-führen basis.

InformationsquelleAutor der Antwort Matt Mitchell

Einigen einfachen code den ich zusammen gestellt habe, fangen Sie die Ausnahmen, die geworfen werden in einem catch-block:

try
{
    //do code here
}
catch (Exception ex)
{
    try { SomeMethod1(); }
    catch { }

    try { SomeMethod2(); }
    catch { }

    try { SomeMethod3(); }
    catch { }
}
finally
{
    //cleanup goes here
}

InformationsquelleAutor der Antwort oscilatingcretin

-2

public static void Main()
{
    for (int j = 0; j <= 100000; j++)
    {
        try
        {
                //TODO: Application logic...
        }
        catch
        {
                System.Threading.Thread.Sleep(1000);
        }
    }
}

InformationsquelleAutor der Antwort planninguk

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.