why must return statement precede a throw statement in a catch block

Question

The code below will complain

try
{
    session.Save(obj);
    return true;
}
catch (Exception e)
{
    throw e;
    return false;  // this will be flagged as         


        

Answer 1

The "return false;" in the catch block is unreachable because of the "throw e;" just before it. When the code executes in the catch block the first line is a throw which means you immediately throw the exception to the calling method and therefore any following code does not get executed.

try
    {
        session.Save(obj);
        return true;
    }
    catch(Exception e)
    {
        throw e; //Throws exception to calling method
        return false;  //this will be flagged as unreachable code

    }

I hope this helps.

Answer 2

return will exit the method; throw will also exit the method, assuming it is not inside the try. It can only exit once!

So regardless of the order - the first of the throw / return effectively end the method.

As more general feedback, though: if the intent is to return false upon failure, all you need is:

try
{
    session.Save(obj);
    return true;
}
catch
{
    return false;
}

Personally, I would say that this is bad code - it hides the actual problem from the caller, making it very hard to debug. It tells us nothing of why it failed. I would say that the better approach is simply to let the exception bubble. In that case, there is no point returning true, because we would never return false - and there is no point catching an exception just to re-throw it. So the entire method becomes:

session.Save(obj);

(nothing else required whatsoever)

---

If your question is "why does only one of these generate a warning": a fair question, but the compiler isn't required to spot either of them for you. Perhaps it should spot it. I suspect that gmcs would spot this and warn about it - the compiler in mono is far more willing to point out stupidity.

---

Edit: as expected, [g]mcs outputs:

Program.cs(15,13): warning CS0162: Unreachable code detected

Program.cs(28,13): warning CS0162: Unreachable code detected

for the code below - so it does indeed report both uses as warnings:

class Program
{
    static void Main() { }
    static void DoSomething() { }
    bool ReturnFirst()
    {
        try
        {
            DoSomething();
            return true;
        }
        catch
        {
            return false;
            throw; // line 15
        }
    }
    bool ThrowFirst()
    {
        try
        {
            DoSomething();
            return true;
        }
        catch
        {
            throw;
            return false; // line 28
        }
    }
}

Answer 3

This answer is based on C# and may or may not be applicable to Java.

In this case, you do not actually need the return statement. throw will be the last step of the function.

In this example, both return and throw will end the current function. Regardless of which way around you put them, then first will always prevent the second from being reachable.

NOTE: The exception to when a throw statement would end the function is if it was to be wrapped in a try block. In this case, the throw function would end execution of the remaining try block code, and move to the most relevant catch block - or finally block if a catch is not applicable.

Your code should look like this:

try
{
    session.Save(obj);

    return true;
}
catch(Exception e)
{
    throw e;
}

However, there is not much point in having the try/catch anyway if all you are doing is re-throwing the exception.

---

To specifically answer your only question:

Why does this defiles my professor's logic?

Well either your professor is wrong, or you have misunderstood them

Answer 4

You are wrong: both your examples raise the Dead code compiler error because both throw and return mark the exit point of a method and no further code is allowed beyond that point.

However, whether the compiler allows it or not, the code below either the throw or the return is still dead and will never get a chance to execute.

(NOTE: this question was initially tagged as Java and my first sentence pertains to Java compiler semantics)

Answer 5

Because any code after the return statement within a code block will be unreachable.