How is it possible to resume code execution after an exception is thrown?
For example, take the following 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) { } } } }
After catching the exception when stepping through, the program will stop running. How can I still carry on execution?
EDIT: What I specifically mean is the line Console.WriteLine(@class); does not seem to be hit, because when I run to it when in debug mode, the program exits from debug mode. I want to run to this line and stop at it.
Thanks
Resuming the program When a checked/compile time exception occurs you can resume the program by handling it using try-catch blocks. Using these you can display your own message or display the exception message after execution of the complete program.
the execution resumes where the exception is caught, that is at the beginning of the catch block which specifically address the current exception type. the catch block is executed, the other catch blocks are ignored (think of multiple catch block as a switch statement).
The continue statement will restart the loop (as opposed to the break statement, which terminates the loop). As such if you replace break; with continue; , you will keep on looping after your Exception is caught (providing no other Exception is thrown but the one caught), ans the error message is displayed.
No. You cannot just jump back into the middle of a method.
Well, you don't have any code after the catch
blocks, so the program would stop running. Not sure what you're trying to do.
The following should be proof that the program doesn't simply "stop" after the catch
blocks. It will execute code after the catch
blocks if there is code to be executed:
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!"); }
The code will print the appropriate string depending on the exception that was caught. Then, it will print I am some code that's running after the exception!
at the end.
UPDATE
In your edit you asked why Console.WriteLine(@class);
does not seem to be hit. The reason is that you are explicitly throwing an exception in the very first line of your s()
method; anything that follows is ignored. When an exception is encountered, execution stops and the exception is propagated up the call stack until the appropriate handler can handle it (this may be a catch
block that corresponds to the try
that wraps the statement in question within the same method, or it may be a catch
block further up the call-stack. If no appropriate handler is found, the program will terminate with a stacktrace [at least in Java - not sure if the same happens in C#]).
If you want to hit the Console.WriteLine
line, then you shouldn't be explicitly throwing an exception at the beginning of the method.
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 love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With