Is this an abuse of try/finally?

Question

Given that multiple return statements are acceptable (I sort of disagree, but let us digress), I'm looking for a more acceptable way to achieve the following behavior:

Option A: multiple returns, repeated code block

public bool myMethod() {     /* ... code ... */      if(thisCondition) {         /* ... code that must run at end of method ... */         return false;     }      /* ... more code ... */      if(thatCondition) {         /* ... the SAME code that must run at end of method ... */         return false;     }      /* ... even more code ... */      /* ... the SAME CODE AGAIN that must run at end of method ... */     return lastCondition; } 

It makes me feel dirty to see the same (little) code block repeated three times each time the method returns. Furthermore, I would like to clarify that the two return false statements above can certainly be described as returning mid-method... they are absolutely not "guard statements."

Is Option B slightly more acceptable? I feel that I may abusing try/finally, and I'm hoping there is something completely different that I should be doing.

Option B: multiple returns, try/finally block (without catch blocks / exceptions)

public bool myMethod() {     try {         /* ... code ... */          if(thisCondition) {             return false;         }          /* ... more code ... */          if(thatCondition) {             return false;         }          /* ... even more code ... */          return lastCondition;     } finally {         /* ... code that must run at end of method ... */     } } 

Finally, Option C is the best solution in my book, but my team doesn't like this approach for whatever reason(s), hence I'm looking for a compromise.

Option C: single return, conditional blocks

public bool myMethod() {     /* ... code ... */      if(!thisCondition) {         /* ... more code ... */     }      if(!thisCondition && !thatCondition) {         /* ... even more code ... */     }      /* ... code that must run at end of method ... */     return summaryCondition; } 

If you want to discuss multiple return statements, please do so in this question.

Answer 1

If the code needs to run even when any other code throws an exception, then the finally block is the correct solution.

If it need not run in the case of an exception (i.e. it's only necessary for "normal" returns), then using finally would be abusing the feature.

Personally I'd rewrite that method in the single-return-point style. Not because I religiously subscribe to that idea (I don't), but because it is best suited for these kind of end-of-method codes.

When that code turns out to be overly complicated (and that's a very real possibility), then it's time to refactor the method by extracting one or more methods.

The simplest refactoring would be something like this:

public boolean  myMethod() {     boolean result = myExtractedMethod();     /* ... code that must run at end of method ... */     return result; }  protected boolean myExtractedMethod() {     /* ... code ... */      if(thisCondition) {         return false;     }      /* ... more code ... */      if(thatCondition) {         return false;     }      /* ... even more code ... */     return lastCondition; }