Should I derive custom exceptions from Exception or ApplicationException in .NET?

According to Jeffery Richter in the Framework Design Guidelines book:

System.ApplicationException is a class that should not be part of the .NET framework.

It was intended to have some meaning in that you could potentially catch "all" the application exceptions, but the pattern was not followed and so it has no value.

You should derive custom exceptions from System.Exception.

Even MSDN now says to ignore ApplicationException:

If you are designing an application that needs to create its own exceptions, you are advised to derive custom exceptions from the Exception class. It was originally thought that custom exceptions should derive from the ApplicationException class; however in practice this has not been found to add significant value. For more information, see Best Practices for Handling Exceptions.

http://msdn.microsoft.com/en-us/library/system.applicationexception.aspx

ApplicationException considered useless is a strong, and critical, argument against ApplicationException.

Upshot: don't use it. Derive from Exception.

The authors of the framework themselves consider ApplicationException worthless:

https://web.archive.org/web/20190904221653/https://blogs.msdn.microsoft.com/kcwalina/2006/06/23/applicationexception-considered-useless/

with a nice follow-up here:

https://web.archive.org/web/20190828075736/https://blogs.msdn.microsoft.com/kcwalina/2006/07/05/choosing-the-right-type-of-exception-to-throw/

When in doubt, I follow their book Framework Design Guidelines.

http://www.amazon.com/Framework-Design-Guidelines-Conventions-Development/dp/0321246756

The topic of the blog post is further discussed there.

rp

I'm used to do:

private void buttonFoo_Click()
{
    try
    {
       foo();
    } 
    catch(ApplicationException ex)
    {
      Log.UserWarning(ex);
      MessageVox.Show(ex.Message);
    }
    catch(Exception ex)
    {
       Log.CodeError(ex);
       MessageBox.Show("Internal error.");
    }
}

It allow to do the difference between:

• C# code system error that I must repairs.
• "Normal" user error that do not need correction from me.

I know it is not recommended to use ApplicationException, but it works great since there is very few classes that do not respect the ApplicationException pattern.