1.5.19 Using Multiple and Early Returns

A Method Can Contain More Than One return Statement

A non-void method may have several possible return statements when different execution paths produce different results.

For example:

public string GetGoalCategory(int goals)
{
    if (goals >= 3)
    {
        return "High scoring";
    }

    if (goals == 2)
    {
        return "Two goals";
    }

    return "Fewer than two";
}

Only one return statement executes during one method call.

A Return Ends the Current Method Immediately

When execution reaches:

return "High scoring";

the method sends that value back to its caller and stops executing.

Statements later in the method are not reached during that call.

This makes a return an execution-flow boundary.

Trace the First Return

Suppose:

goals = 4

The first condition:

goals >= 3

is true.

The method executes:

return "High scoring";

and finishes immediately.

The later condition:

goals == 2

is not evaluated.

Trace a Later Return

Suppose:

goals = 2

The first condition is false.

Execution continues.

The second condition is true.

The method executes:

return "Two goals";

and finishes.

The final return is not reached.

The Final Return Covers the Remaining Path

For:

goals = 1

both earlier conditions are false.

Execution reaches:

return "Fewer than two";

This final return supplies the result for all remaining values.

An Early Return Can Handle a Special Case First

An early return occurs before the normal end of the method.

Suppose:

public string GetTeamName()
{
    if (this.team == null)
    {
        return "No team";
    }

    return this.team.name;
}

The null case is handled immediately.

If the Team reference is null, the method returns:

"No team"

and stops.

Only when the reference exists does execution continue to:

return this.team.name;

Early Returns Can Make a Guard Condition Clear

A guard-style early return answers:

For the Team example:

team is null?
  ├─ yes → return "No team"
  └─ no  → continue and use team

This can make the method's flow straightforward.

Multiple Returns Still Need Complete Path Coverage

Having several return statements does not automatically mean every path returns.

You still need to trace every possible execution path.

For example:

public int GetScore(int goals)
{
    if (goals > 0)
    {
        return goals;
    }
}

The positive path returns.

The zero-or-lower path does not.

The method still has an incomplete path.

Every Return Must Match the Declared Type

For:

public string GetGoalCategory(int goals)

every return must produce a string-compatible value.

The method cannot return an integer in one branch merely because that value is convenient.

The method contract applies to every return statement.

Multiple Returns Are Different from Multiple Returned Values at Once

A single method call returns one result.

A method with three return statements does not send three values back.

It has three possible places where execution may finish.

Only the return reached by the selected path executes.

Use the Requirement to Decide Whether an Early Return Helps

Do not add early returns simply because they are allowed.

Use them when the method's logic becomes clearer.

A good early return often handles a condition that makes the normal remainder of the method unnecessary.

Compare Two Valid Structures

if/else

public string GetAvailabilityText()
{
    if (this.isAvailable)
    {
        return "Available";
    }
    else
    {
        return "Unavailable";
    }
}

Early return plus final return

public string GetAvailabilityText()
{
    if (this.isAvailable)
    {
        return "Available";
    }

    return "Unavailable";
}

Both can produce the same result.

The important requirement is that the logic is correct and every path returns the promised type.

Key Reasoning Questions

When reading multiple returns:

Which condition leads to each return?
Which returns are skipped after an earlier return executes?
Does every possible path reach one return?
Does every returned value match the declared type?
Does each result match the requirement?

Multiple returns are easiest to understand when you trace one complete path at a time.