C# Catch re-throw/propagation for a specific exception type

Question

I am trying to propagate to my UI the GatewayConnectionFailedException as you can see. I want this code to catch everything except that exception which I want the presentation layer to catch to notify the user that the database was the problem so he can go and fix it. My problem is that when I throw it the first time then I get GatewayConnectionFailedException not handled by user code on the GatewayException catch clause.

Its also important to note the the GatewayConnectionFailedException extends GatewayException which extends Exception. Is there something I am missing or will I have to move all the catch to the presentation layer ?

        try
        {
             something();
        }
        catch (GatewayConnectionFailedException gcfe)
        {
            throw;
        }
        catch (GatewayException ge)
        {
            if (ge.GetType() == typeof(GatewayConnectionFailedException))
                throw;
            string errMsg = "Records could not be retrieved due to a data gateway error. " + GetTypeInfo();
            _logger.Error(errMsg + "\r\n{0}", ge);
        }
        catch (Exception e)
        {
            if (e.GetType() == typeof(GatewayConnectionFailedException))
                throw;
            string errMsg = "Records could not be retrieved due to an unexpected error. " + GetTypeInfo();
            _logger.Error(errMsg + "\r\n{0}", e);
        }

Answer 1

Stupid question... is your UI code try-catching in it's call to this layer? Something has to handle that second throw...

In a nutshell, it sounds like you're trying to do this:

using System;

namespace ConsoleApplication1
{
    class ExceptionA : Exception
    {
        public override string Message
        {
            get
            {
                return "Exception A";
            }
        }
    }

    class ExceptionB : ExceptionA
    {
        public override string Message
        {
            get
            {
                return "Exception B";
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                DoThing();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Caught in 'UI' code: " + ex.Message);
            }
        }

        static void DoThing()
        {
            try
            {
                throw new ExceptionB();
            }
            catch (ExceptionB ex)
            {
                Console.WriteLine("Caught B");
                throw;
            }
            catch (ExceptionA ex)
            {
                Console.WriteLine("Caught A");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Caught Generic");
            }
        }
    }
}

Which yields this output:

Caught B
Caught in 'UI' code: Exception B
Press any key to continue...

It just seems like you don't have anything catching the 2nd thrown exception, which is why it's "unhandled." If we comment out the try-catch in main, we end up with an unhandled exception:

static void Main(string[] args)
        {
            //try
            //{
            DoThing();
            //}
            //catch (Exception ex)
            //{
            //Console.WriteLine("Caught in 'UI' code: " + ex.Message);
            //}
        }

Yielding the following output:

Caught B

Unhandled Exception: ConsoleApplication1.ExceptionB: Exception B at ConsoleApplication1.Program.DoThing() in C:\Users\Giovanni\AppData\Local\T emporary Projects\ConsoleApplication1\Program.cs:line 50 at ConsoleApplication1.Program.Main(String[] args) in C:\Users\Giovanni\AppDa ta\Local\Temporary Projects\ConsoleApplication1\Program.cs:line 33 Press any key to continue . . .

Answer 2

Instead of using throw exceptionName try only throw.

Edit 1:
Try catching all exceptions in the same block, then throw back the exception only if it's the GatewayConnectionFailedException

try
{
     something();
}
catch (Exception e)
{
    if (e.GetType() == typeof(GatewayConnectionFailedException))
        throw;
    string errMsg = "Records could not be retrieved due to an unexpected error. " + GetTypeInfo();
    _logger.Error(errMsg + "\r\n{0}", e);
}

Answer 3

One item to not although this might not fix the exception, if you are catching and rethrowing the exception use this code instead:

catch (GatewayConnectionFailedException)
{
    throw;
}

this way the stacktrace reflects the programs journey more accurately. It may not solve the issue though.

Answer 4

Hard to tell what is missing without full picture, but one important thing that you should throw exceptions in different way. The syntax should be

throw;

you will have full stacktrace. More info.

Answer 5

Catching of GatewayConnectionFailedException should solve your problem and in catch block just do throw, don't throw the exception object. Answer by Andy is correct.

Secondly I'm assuming GatewayConnectionFailedException inherits from GatewayException.

Select catch sequence in ascending of order of inheritance, child class should come first and then base class.

catch(Child){}
catch(Base){}
catch(Exception) {} //Base class for all exceptions

Answer 6

to start your try catch is redundant. the first catch will handle GatewayConnectionFailedException the remaining catches will never be of type GatewayConnectionFailedException because they were handled by the first catch. so the code can be simplified to

try
{
    something();
}
catch (GatewayConnectionFailedException)
{
    throw;
}
catch (GatewayException e)
{
    _logger.Error(e.Message, e);
}

Now how the UI will handle this depends on how you handle the exception. if you just throw the exception, then you need a try catch in the presentation layer as well. However if the return type of this layer returned an object like

class Result<T>
{
     T Value {get;set;}
     Exception Error {get;set;}
}

Then you could simply process the type without need try/catch in the presentation layer.

Also worth noting is what you are catching and why you are trying to catch it. typically you don't want to catch Exception except at the application layer where you log the error and fail. Exceptions should be exceptional, and therefore only catch exceptions you expect can happen and why they may happen. otherwise let them bubble up.