Creating your own exception and use it in C#

Question

I am trying to understand how to use a custom exception in the right way.

I have used try/catch many times but never understod when to use your own class off exceptions. I have read and watch some off the many tutorials out there, but I can't get my head around this.

This is my CustomException class:

[Serializable]
    class CustomException : FormatException
    {
        /// <summary>
        /// Just create the exception
        /// </summary>
        public CustomException()
        : base() {
        }
        /// <summary>
        /// Create the exception with description
        /// </summary>
        /// <param name="message">Exception description</param>
        public CustomException(String message)
        : base(message) {
        }
        /// <summary>
        /// Create the exception with description and inner cause
        /// </summary>
        /// <param name="message">Exception description</param>
        /// <param name="innerException">Exception inner cause</param>
        public CustomException(String message, Exception innerException)
        {
        }
    }

This is where I try to use it:

    /// <summary>
    /// Checks if parse works
    /// </summary>
    /// <returns></returns>
    public static int ParseInput(string inInt)
    {
        try
        {
            int input = int.Parse(inInt);
            return input;
        }
        catch (CustomException)
        {
            throw new CustomException();
        }
        catch (Exception ex)
        {
            MessageBox.Show("Use only numbers! " + ex.Message);
            return -1;
        }

    }

Now what do I do wrong? Becuse the program crash att this line int input = int.Parse(inInt);, it never comes to my custom exception? If I do use the classic Exception class it all works.

MSDN: [Designing Custom Exceptions](https://msdn.microsoft.com/en-us/library/vstudio/ms229064.aspx) — D Stanley, Sep 11 '15 at 16:54
`int.Parse` knows _nothing_ about your custom exception type, so there's no possible way that it can throw one. — D Stanley, Sep 11 '15 at 16:55

score 8 · Answer 1 · answered Sep 11 '15 at 16:52

8

CustomException you defined is a more specific class than the base FormatException (this is what inheritance is about). You cannot catch a more generic exception with a more specific one. Only the other way.

answered Sep 11 '15 at 16:52

Slava

108
4

Thorsten Dittmar · Accepted Answer · 2015-09-11T17:01:10.500

In your code you are only throwing your type of exception when you caught it before, which will never happen, as the system will not throw it.

Normally you would do something like this.

try
{
    // do something 
    if (some condition) 
        throw new MyCustomException() ;
} 
catch (SomeOtherException e) 
{
    // Handle other exceptions 
}

In your case, the system will throw a FormatException, but not your own exception class, as it doesn't know about it. As your exception class is more specific as the FormatException, the catch block will not be called. However, it should work like this:

public static int ParseInput(string inInt)
{
    try
    {
        int input = int.Parse(inInt);
        return input;
    }
    catch (FormatException e)
    {
        throw new CustomException("Format error!", e);
    }
    catch (Exception ex)
    {
        MessageBox.Show("Use only numbers! " + ex.Message);
        return -1;
    }
}

In addition, your code has one flaw: When any Exception is caught, a message will be displayed to the user and -1 will be the return value (is -1 not a valid input...?). When a FormatException is caught, error handling is left to the called by re-throwing the exception - why?

Please remember that exceptions don't "fall through":

try
{
}
catch (FormatException e1)
{
    // This will throw an exception, but it will **not** be caught here,
    // but control goes back to the caller
    throw new Exception();
}
catch (Exception e2) 
{
    // This block will not get called when an exception occurs in 
    // above handler. It will only get called when an exception other
    // than FormatException occurs.
}

First your awnser helpt me understand how it works, thanks for that! Second.. mabey a dumb question but after the throw have caught the exception the program stops.. and i cant figure out how to make the program continue after the exception...? — Newbie1337, Sep 12 '15 at 15:41
You need to put the call to your method into a `try-catch` block of course as now the method will throw an exception. — Thorsten Dittmar, Sep 12 '15 at 18:50

score 2 · Answer 3 · answered Sep 11 '15 at 16:57

Let me start my answer with a question: How do you think you could catch a given exception when it does not occur in the code?

The code here:

int input = int.Parse(inInt);

throws FormatException in case of an error, but not your very own CustomException.

You have to throw it within your own code in order to catch it:

try
{
    …
    // the execution of this code needs to lead to throwing CustomException…
    throw new CustomException();
    …
}
// … for a handler of CustomException to make any sense whatsoever
catch (CustomException e)
{
    … handle here …
}

score 1 · Answer 4 · edited Sep 11 '15 at 17:04

1

Well, it happens because int.Parse(int ) in your case raises FormatException and know nothing (John_Snow_face.jpg) about your custom exception. You can use TryParse method :

int number;
bool result = Int32.TryParse(value, out number);
if(!result)
throw new CustomException("oops");

edited Sep 11 '15 at 17:04

Thorsten Dittmar

55,956
8
91
139

answered Sep 11 '15 at 16:55

funkyCatz

119
1
2

Creating your own exception and use it in C#

4 Answers4