Exists a better code (e.g. For global error handling) on error handling in C# than try...catch with more error information as well (error number and error code line)?

Question

1.00/5 (1 vote)

See more:

, +

I would like to save a lot of time and space in my C# application not to surround each single line of code with a "try...catch" construct to avoid errors. It obscures my code and to type it each time is tiring off. I seek to do some global error handling.

Example (VB 6): On Error Resume Next. (=error handling done for whole application with a one-liner. Code get executed no matter what!)

Is there something alike for C#?
And then I would need some more error information on the exceptions. Just to know that there was an exception of type XY is not enough for me.
I need the error number (e.g. error no. 56) and the error line (error in line 578 e.g.) (code line number where the error happened) and function name (e.g. "void form_load(...)") where the error was triggered.
C# seems not to supply such informations on exceptions. So I have a hard time to figure out, what the error is about. Any ideas on this?

What I have tried:

C#

try
{
//here the code line to handle
}
catch(Exception Ex1){MessageBox.Show(Ex1.Message); Process.Start("shutdown" "-f");}

This provides me not enough information about the error. I would like to see the error number (e.g. error no. 65) and the error code line (e.g. error in line 578) to have more tracking informations about what exactly happened.

Then I would need a global error handling on whole application, not this per line thing all the time.

Any solutions or better global error handling commands on this?
try...catch is definitely not the thing for me to go.

Any logoff dialog before shutting down the whole system on error would be also nice.

Posted 12-Apr-16 2:09am

ByeByeByeByeBye

Updated 12-Apr-16 3:59am

v2

Add a Solution

Comments

Richard Deeming 12-Apr-16 10:09am

Shutting down the computer every single time an error occurs is a terrible idea! Any program that tried to do that would quickly be uninstalled from any system, and a refund demanded.

You seem to be stuck in "VB6-mode". Forget what VB6 did, and embrace proper structured exception handling.

Don't wrap each line of code in a try..catch block. Instead, wrap a logical section of code which could throw an exception which you can handle in a try..catch block, catching the specific exception types that your code can handle, and handling them appropriately.

Let any exceptions that you can't handle fall-through to the calling code.

Have a top-level try..catch block on your entry-point which logs unhandled exceptions and terminates the program. NB: DO NOT try to shut down or restart the computer just because your program has an unhandled exception!

Use the StackTrace to see where the exception was thrown, and the chain of methods that were called to get there. (Much better than VB6's Err object!) Look at the InnerException to see if the exception you've caught is a wrapper for a lower-level exception.

SEH is far superior to VB6's error handling, if only you'd embrace it properly! :)

Sergey Alexandrovich Kryukov 12-Apr-16 11:55am

VB6 does not have structural exception handling. That means, it has nothing.

With .NET, you don't need anything as in VB6.

—SA

Richard Deeming 12-Apr-16 14:22pm

It's far from "useless" - the combination of the exception type and message provides far more detail than error 42. Combined with the additional detail provided by the exception class, it gives you everything you need to diagnose and resolve the error.

Richard Deeming 12-Apr-16 14:23pm

For Windows Forms, use Application.Exit(); to terminate the application.

Alternatively, use Environment.Exit(exitCode); to terminate the process and return an exit code to Windows.

Richard Deeming 12-Apr-16 15:52pm

Use one or the other; any code following either method call will not execute.

Remove the "shutdown" command, since you don't want to shut down the computer.

2 solutions

Solution 2

I am assuming you want to catch and do something with all unhandled exceptions within your code. I will leave it to you to put the proper using statements at the top of your files.

Do something like this:

In your main within program.cs near the beginning of the function:

C#

Application.ThreadException += new ThreadExceptionHandler(UnhandledExceptionEventHandler);

Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);

AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);

Then, write your handlers like this:

C#

public void CurrentDomain_UnhandledException(object sender,  UnhandledExceptionEventArgs e)
{
    ExceptionHandler((Exception)e.ExceptionObject);
}

public void UnhandledExceptionEventHandler(object sender, ThreadExceptionEventArgs e)
{
    ExceptionHandler(e.Exception);
}

public void ExceptionHandler(Exception e)
{
    string result = FormatException(e, string.Format("Information: {0}\n\n", Assembly.GetEntryAssembly().GetName()));


    // Do what you want with the result here.
}

public string FormatException(Exception e, params string[] information)
{
    Exception ex = e;
    StringBuilder sb = new StringBuilder();

    if (information != null)
    {
        foreach (string s in information)
            sb.Append(s);
    }
    while (ex != null)
    {
        sb.AppendLine(ex.GetType().ToString());
        sb.AppendLine(ex.Message);
        sb.AppendFormat("\n\nStack Trace:\n{0}", ex.StackTrace);
        ex = ex.InnerException;
        if (ex != null)
             sb.AppendFormat("\n\nInner Exception:\n\n");
    }
    return sb.ToString();
}

Posted 12-Apr-16 3:59am

David Knechtges

Comments

Sergey Alexandrovich Kryukov 12-Apr-16 12:01pm

Good, but this answer assumes that the inquirer uses System.Windows.Forms. WPF has different but similar system, as well as nearly all modern non-nonsense library.
However, our inquirer is totally lost in the topic, it can hardly practically help. If a person needs to learn what is structural exception handling, it's like creating a new cortical fold. :-)
—SA

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

CHill60 · Accepted Answer · 2016-04-12T02:24:00

Solution 1

The Exception class can provide a great deal of detail if you need it, including the line number and a complete stack trace. Examine the output from this code snippet for a demonstration:

C#

private void input_btn_Click(object sender, EventArgs e)
{
    try
    {
        int x = 0;
        int y = 1;

        int z = y / x;

    }
    catch (Exception ex)
    {
        Console.WriteLine("--------------------");
        Console.WriteLine(ex.Message);
        Console.WriteLine("--------------------");
        Console.WriteLine(ex.ToString());
        Console.WriteLine("--------------------");
        Console.WriteLine(ex.StackTrace);
    }
}

For better global error handling techniques then this article is a must-read Exception Handling Best Practices in .NET[^]

As is this Vexing exceptions | Fabulous Adventures In Coding[^]

Posted 12-Apr-16 2:24am

CHill60

Comments

Richard Deeming 12-Apr-16 10:01am

What? Did you even try the code? Of course it handles the exception - that's what the catch block is for!

The information about procedures and line numbers comes from the stack trace - ex.StackTrace. That will tell you exactly where the exception was thrown, and the methods that were called to get to that point. It gives you a lot more information than VB6's Err object.

The calculation in the answer is just an example of code that throws an exception.

CHill60 12-Apr-16 11:17am

As @RichardDeeming has pointed out - the code I presented was not meant to be a solution - it was for you to see just how much more information is available in the Exception object than just the message.
The actual solution is given in the two links I included.

Richard Deeming 12-Apr-16 14:19pm

catch (Exception ex)
{
   MessageBox.Show(ex.ToString());
   Application.Exit();
}

It's still a bad idea to close your application on every exception - there are plenty of exceptions which you can handle gracefully.

Sergey Alexandrovich Kryukov 12-Apr-16 12:02pm

You cannot do programming without learning how structural exception handling works; and right now you don't have a clue. Do yourself a big favor, learn the concept first.
—SA

Sergey Alexandrovich Kryukov 12-Apr-16 12:03pm

I voted 4; and it's not 5 only because this is not what inquirer can understand well right now; he rather need to learn the whole concept.
—SA

Richard Deeming 12-Apr-16 13:36pm

try..catch is the mechanism for handling exceptions in .NET; asking for a way to handle / ignore exceptions without try..catch makes no sense.

And if you want to write a program that ignores all exceptions, then you're doing it wrong.

Richard Deeming 12-Apr-16 13:39pm

Exceptions are thrown when your code tries to do something wrong - for example, dividing by zero, converting the string "hello" to a date, reading a file that doesn't exist, etc.

Millions of developers around the world use SEH to write correct and resilient programs every day.

What makes you think that Microsoft should issue a "hotfix" to turn off SEH and ignore all errors, just because you can't be bothered to learn the .NET way of handling errors, and want to live in the 90s?

Richard Deeming 12-Apr-16 14:13pm

So what do you think is more likely:

A) Visual Studio has a bug that causes unhandled exceptions in your "perfect" code, and none of the millions of developers who use Visual Studio every day have seen it yet; or

B) There's something wrong with your code.

Guess which option my money's on?

Richard Deeming 12-Apr-16 14:46pm

We can't see your code, so we can't tell you where the error is or what's causing it. If you run the code in Visual Studio, you'll get the option to break when an unhandled exception occurs, which will let you see the exact line that's causing the error, and examine the variables to ensure they contain what you think they should.

Methods with hundreds of lines are painful to work with, as you're discovering. Break the method up into smaller methods, and then it will be easier to maintain and debug.

Richard Deeming 12-Apr-16 15:20pm

No, if your code has compiler errors, then it cannot be compiled, and it cannot run.

You need to fix those errors before you can start your application.

Richard Deeming 12-Apr-16 15:21pm

There is no option to ignore compiler errors. Unlike VB6, C# is not an interpreted language; you can't just start the program and then get a runtime error when your code can't be compiled.

Richard Deeming 12-Apr-16 15:24pm

Modules make it harder to separate code, because you're calling methods without knowing where they're defined. Use classes to separate your code.

Unlike VB6, C# does not create a default instance of every form for you behind the scenes. You have to create and manage the instances of the forms yourself. Once you get to grips with the basic concepts of OOP, this is much simpler than the VB6 model!

Based on your question and the follow-up comments, it sounds like you really need to go through a few tutorials on the basics of writing OOP code.

Richard Deeming 12-Apr-16 15:29pm

No, they're errors in the syntax of your code. They're problems with your code, and nothing to do with Microsoft.

Richard Deeming 12-Apr-16 15:48pm

Object Oriented Programming[^]
Object-Oriented Programming (C# and Visual Basic)[^]
Object Oriented Programming Using C# .Net[^]

Richard Deeming 12-Apr-16 15:50pm

The unhandled exception dialog box comes up when an exception is thrown by your code or code that you've called, and is not handled anywhere within your application.

Adding the code from Solution 2 to your Main method, along with a top-level try..catch block wrapping the contents of your Main method and logging any unhandled exceptions should prevent that dialog box from showing.

Richard Deeming 12-Apr-16 16:00pm

No, it's a static method called Main, usually to be found in a class called Program. By default, it looks something like:

static class Program
{
   [STAThread]
   static void Main()
   {
      Application.EnableVisualStyles();
      Application.SetCompatibleTextRenderingDefault(false);
      Application.Run(new Form1());
   }
}

CHill60 15-Apr-16 9:04am

Stack trace shows the function name, the line number, the code module in which it can be found.
You should not suppress errors.
My answer is relevant to the question and has been marked as "accepted" so no, I will not remove it