Catch multiple Exceptions at once?

Question

It is discouraged to simply catch System.Exception, instead only the "known" Exceptions should be caught.

Now, this sometimes leads to unneccessary repetetive code, for example:

            try
            {
                WebId = new Guid(queryString["web"]);
            }
            catch (FormatException)
            {
                WebId = Guid.Empty;
            }
            catch (OverflowException)
            {
                WebId = Guid.Empty;
            }

I wonder: Is there a way to catch both Exceptions and only call the WebId = Guid.Empty call once?

Edit: the given example is rather simple, as it's only a Guid. But imagine Code where you modify an object multiple times, and if one of the manipulations fail in an expected way, you want to "reset" the object. However, if there is an unexpected Exception, I still want to throw that higher.

About the Answer: Thanks everyone! For some reason, I had my mind set on a switch-case statement which does not support switching on GetType(). Now, there were two answers, one using "typeof" and one using "is". I first thought "typeof()" would be my Function because I thought "Hey, I only want to catch FormatException because that's the only thing I expect". But that's not how catch() works: catch also catches all derived exceptions. After thinking about it, this is really obvious: Otherwise, catch(Exception ex) would not work! So the correct answer is "is". Yay, learned two things with only one question \o/

Answer 1

Note that I did find one way to do it, but this looks more like Material for TheDailyWTF:

            catch (Exception ex)
            {

                switch (ex.GetType().Name)
                {
                    case "System.FormatException":
                    case "System.OverflowException":
                        WebId = Guid.Empty;
                        break;
                    default:
                        throw;                           
                }
            }

Answer 2

How about try

        {
            WebId = Guid.Empty;
            WebId = new Guid(queryString["web"]);
        }
        catch (FormatException)
        {
        }
        catch (OverflowException)
        {
        }

Answer 3

Catch System.Exception and switch on the types

       catch (Exception ex)            
       {                
           if (ex is FormatException ||
               ex is OverflowException)
           {
               WebId = Guid.Empty;
               return;
           }
           else
           {
               throw;
           }
       }

Answer 4

@Micheal

Slightly revised version of your code:

catch (Exception ex)
{
   Type exType = ex.GetType();
   if (exType == typeof(System.FormatException) || 
       exType == typeof(System.OverflowException)
   {
       WebId = Guid.Empty;
   } else {
      throw;
   }
}

String comparisons are ugly and slow.

Answer 5

Here's a method that doesn't convert the Type Name to a string, but instead compares Types directly:

try
{
    WebId = new Guid(queryString["web"]);
}
catch (Exception ex)
{
    if (ex is FormatException || ex is OverflowException)
    {
        WebId = Guid.Empty;
    }
}

Answer 6

Not in C# unfortunately, as you'd need an exception filter to do it and C# doesn't expose that feature of MSIL. VB.NET does have this capability though, e.g.

Catch ex As Exception When TypeOf ex Is FormatException OrElse TypeOf ex Is OverflowException

What you could do is use an anonymous function to encapsulate your on-error code, and then call it in those specific catch blocks:

Action onError = () => WebId = Guid.Empty;
try
{
    // something
}
catch (FormatException)
{
    onError();
}
catch (OverflowException)
{
    onError();
}

Answer 7

   catch (Exception ex)            
   {                
       if (ex is FormatException ||
           ex is OverflowException) 
       {} else throw;

       WebId = Guid.Empty;
   }

Answer 8

        catch (Exception ex)
        {
            if (!(
                ex is FormatException ||
                ex is OverflowException))
            {
                throw;
            }

            Console.WriteLine("Hello");
        }

Answer 9

The accepted answer seems acceptable, except that CodeAnalysis/FxCop will complain about the fact that it's catching a general exception type.

Also, it seems the "is" operator might degrade performance slightly. http://msdn.microsoft.com/en-us/library/ms182271.aspx says to "consider testing the result of the 'as' operator instead", but if you do that, you'll be writing more code than if you catch each exception separately.

Anyhow, here's what I would do:

bool exThrown = false;

try
{
    // something
}
catch( FormatException ){ exThrown = true; }
catch( OverflowException ){ exThrown = true; }

if( exThrown )
{
    // something else
}

Answer 10

@Joseph

I like your solution, but it seems to me like it would be better to catch the closest ancestor exception class instead of catching the general Exception class. In this case, it would be SystemException. So I would use the exact same code as you, but with SystemException instead of Exception inside the catch statement.

It is easy to find the closest ancestor class simply by looking up the two different exception classes on MSDN, which gives their full inheritance hierarchies all the way back to the Object class.

@Andrew

Perhaps this would also alleviate FxCop's complaints about catching general exceptions, which you previously commented on in Joseph's solution.