Silence specific Exception

Question

I have a lot of throw new NotImplementedExceptions() throughout my whole application. For now I want to silence them and to show a custom Message Dialog instead.

For catching them I'm using:

AppDomain.CurrentDomain.FirstChanceException += (sender, eventArgs) =>
{
     if(eventArgs.Exception is NotImplementedException) {
        return;
     }
}

But the problem is that the exception is still threw.

How can I silence the throw when I catch this type of Exception within this piece of code?

Answer 1

It sounds like what you want to do is to do something nicer than exploding when a method you haven't implemented is invoked. I don't believe that is possible using AppDomain.FirstChanceException or the related UnhandledException. There's a good answer here that talks a bit about why simply suppressing exceptions is undesirable.

What you could do instead is use something besides raising an exception to mark methods as not implemented, like calling a helper that displays your message, when you haven't implemented something yet. You could use #if pragmas or the ConditionalAttribute to switch to actually throwing exceptions in non-DEBUG builds, if that's desirable. It's not that uncommon to use helpers for throwing exceptions anyway (see for example ThrowHelper in the BCL, or Throw in one of my own projects), as there are some benefits to avoiding throws.

This would look like:

public void UnImplementedMethod()
{
  // rather than "throw new NotImplementedException("some message")"
  MyHelper.NotImplemented("some message");
}

// .... 

static class MyHelper
{
  [Conditional("DEBUG")]  
  public static void NotImplemented(string msg)
  {
#if DEBUG // can use whatever configuration parameter
      MessageBox.Show("Not Implemented: "+ msg);
#else
      throw new NotImplementedException(msg);
#endif
  }
}

You can use generic parameters to handle unimplemented methods that have non-void returns, though you have to decide what to actually return if you don't throw an exception. With this pattern you can do whatever you'd like, and still easily find places that haven't been implemented.