Can you catch more than one type of exception with each block?

Question

This question is close to what I want to do, but not quite there.

Is there a way to simplify the following code?

private bool ValidDirectory(string directory)
{
    if (!Directory.Exists(directory))
    {
        if (MessageBox.Show(directory + " does not exist. Do you wish to create it?", this.Text) 
            == DialogResult.OK)
        {
            try
            {
                Directory.CreateDirectory(directory);
                return true;
            }
            catch (IOException ex)
            {
                lblBpsError.Text = ex.Message;
            }
            catch (UnauthorizedAccessException ex)
            {
                lblBpsError.Text = ex.Message;
            }
            catch (PathTooLongException ex)
            {
                lblBpsError.Text = ex.Message;
            }
            catch (DirectoryNotFoundException ex)
            {
                lblBpsError.Text = ex.Message;
            }
            catch (NotSupportedException ex)
            {
                lblBpsError.Text = ex.Message;
            }
        }
    }

    return false;
}

It seems a waste, and if I later want to change how I report an error back to the user, or perhaps I want to log these errors, or whatever, then I've got to change 5 different catch blocks. Am I missing something, or is this blatantly against code-reuse?

Am I just trying to be (too) lazy?

Answer 1

You can do

ex.GetType()

see http://msdn.microsoft.com/en-us/library/system.exception.gettype.aspx

EDIT

try            
{                
    Directory.CreateDirectory(directory); 
    return true;           
}            
catch (Exception ex)            
{   switch(ex.GetType())
         case .....
         case ..........
    blBpsError.Text = ex.Message;            
}

Answer 2

If the exceptions share a common super-class then you can just catch the superclass.

Answer 3

You can catch a base class exception (all your exceptions derive from SystemException):

try
{
  Directory.CreateDirectory(directory);
  return true;
}
catch (SystemException ex)
{
  lblBpsError.Text = ex.Message;
}

But then you may end up catching exceptions you don't want to catch.

Answer 4

You can use :

catch (SystemException ex)
{
  if(    (ex is IOException)
      || (ex is UnauthorizedAccessException )
// These are redundant
//    || (ex is PathTooLongException )
//    || (ex is DirectoryNotFoundException )
      || (ex is NotSupportedException )
     )
       lblBpsError.Text = ex.Message;
    else
        throw;
}

Answer 5

Yes, you're trying to be lazy, but laziness is one of the virtues of a programmer, so that's good.

As for your question: There is no way I am aware of, but there are some workarounds available:

• Give the Exceptions a common ancestor. I think this won't be possible in your case, since they seem to be builtin.
• Catch the most generic exception you can.
• Move the handling code into its own function and call that from each catch block.

Answer 6

This is annoying, and other answers have suggested good workarounds (I'd use @Lotfi's).

However this behaviour is a requirement given the type-safety of C#.

Suppose you could do this:

try
{
    Directory.CreateDirectory(directory);
    return true;
}
catch (IOException, 
    UnauthorizedAccessException,
    PathTooLongException,
    DirectoryNotFoundException,
    NotSupportedException ex)
{
    lblBpsError.Text = ex.Message;
}

Now what type is ex? They all have .Message because they inherit System.Exception, but try accessing any of their other properties and you have a problem.

Answer 7

Its also important to note that when catching more then one type of exception they should be order by most specify to most general. The Exception will find the first one in the list that it matches and throw that error, none of the other errors will be thrown.

Answer 8

You could use delegates, this will do what you want:

EDIT: simplified a bit

static void Main(string[] args)
{
    TryCatch(() => { throw new NullReferenceException(); }, 
        new [] { typeof(AbandonedMutexException), typeof(ArgumentException), typeof(NullReferenceException) },
        ex => Console.WriteLine(ex.Message));

}

public static void TryCatch(Action action, Type[] exceptions, Action<Exception> catchBlock)
{
    try
    {
        action();
    }
    catch (Exception ex)
    {
         if(exceptions.Any(p => ex.GetType() == p))
         {
             catchBlock(ex);
         }
         else
         {
             throw;
         }
    }
}

Your particular try/catch would be:

bool ret;
TryCatch(
    () =>
        {
            Directory.CreateDirectory(directory);
            ret = true;
        },
    new[]
        {
            typeof (IOException), typeof (UnauthorizedAccessException), typeof (PathTooLongException),
            typeof (DirectoryNotFoundException), typeof (NotSupportedException)
        },
    ex => lblBpsError.Text = ex.Message
);

return ret;

Answer 9

I understand some of these exceptions may not be foreseeable but where possible try to implement your own "pre-emptive" logic. Exceptions are expensive, though in this case probably not a deal breaker.

For example, use Directory.GetAccessControl(...) rather than relying on an UnauthorizedAccessException to be thrown.

Answer 10

Just for completeness’ sake:

In VB, you could use conditional exception handling:

Try
    …
Catch ex As Exception When TypeOf ex Is MyException OrElse _
                           TypeOf ex Is AnotherExecption
    …
End Try

Such a Catch block would only get entered for the specified exceptions – unlike in C#.

Perhaps a future version of C# will offer a similar feature (after all, there's a specific IL instruction for that code).

MSDN: How to: Filter Errors in a Catch Block in Visual Basic

Answer 11

Check out the The Exception Handling Application Block from EntLib. They articulate a very nice policy and configuration based exception handling methodology that avoids large conditional logic blocks.