Resuming execution of code after exception is thrown and caught

It sounds like you're wanting resumeable exceptions. C# doesn't do resumeable exceptions, and I'm doubtful that CLR supports them.

The purpose of throwing an exception is to abort a function and an entire operation (call stack) if/when something in the call environment (parameters, object state, global state) makes the function's operation impossible or invalid. Passing a zero param to a function that needs to divide a quantity by that param, for example. Division by zero won't produce a meaningful result, and if that's the sole purpose of the function, then the function can't return a meaningful result either. So, throw an exception. This will cause execution to jump to the nearest catch or finally block on the call stack. There is no returning to the function that threw the exception.

If you want to step into your code in the debugger to trace the Console.WriteLine() calls, you need to remove the throw new NotSupportedException() line from your code and recompile.

If you're worried that an exception will be thrown in the method but you want the method to continue, add an error handler inside the method.

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

You could also return a bool or some other value to indicate the state.

Disclaimer: I am not suggesting that you actually do this.

You can mimic the old VB style On Error Resume Next with the following code.

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

And then it could be used like the following.

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

Some simple code I put together to catch exceptions that are thrown inside a catch block:

try { //do code here } catch (Exception ex) { try { SomeMethod1(); } catch { } try { SomeMethod2(); } catch { } try { SomeMethod3(); } catch { } } finally { //cleanup goes here } 

Execution is still carying on but there is no code after the exception is caught. If you want to repeatedly call s then consider wrapping the try/catch block in a while loop.

The program stops running because there is no following code to be executed in the Main() method! You can add the following line to your code to keep the program running until there is a console input:

Console.ReadLine(); 

For that code, you can't. If you break the tasks up to smaller chunks, you can resume at the next chunk. But normally it's easier to have a different mechanism than exceptions to report non-fatal errors, such as a callback function which returns whether or not to continue.

You can use the "step-over" feature in debugging to achieve this on a per-run basis.

Instead of thowing the NotSupportedException, you could track that an exception was encountered, use a default value, and throw the exception at the end of the method call:

namespace ConsoleApplication1 { public class Test { public void s() { bool exceptionEncountered = false; if(someConditionNotSupported){//stub condition exceptionEncountered=true @class="DefaultValue"; } Console.WriteLine(@class); Console.ReadLine(); if(exceptionEncountered){ throw new NotSupportedException(); } } } public class Program { public static void Main(string[] args) { try { new Test().s(); } catch (ArgumentException x) { } catch (Exception ex) { } } } }