Question

Should I save a result from a switch statement before returning it? Or should I return the value in the switch when I get it? Is there one way over another that is better style?

With a temporary variable:

      public double xMax {
      get {
           double val = 0.00f;
           switch(x_option) {
                case 0:
                     val = priMax;
                     break;
                case 1:
                     val = rfMax;
                     break;
                case 2:
                     val = pwMax;
                     break;
           }

           return val;
      }
 }

With return statement:

 public double xMax {
      get {
           double val = 0.00f;
           switch(x_option) {
                case 0:
                     return priMax;
                case 1:
                     return rfMax;
                case 2:
                     return pwMax;
           }
      }
 }

Is there a performance difference and/or cleanup?

Answer 1

Personally I prefer the second form. It makes it immediately clear that as soon as you’ve got to the return statement, you’re done. With the extra variable version, you have to look through the rest of the code to see if anything else will happen.

The dogma around a single point of return made sense in C, where you’d want to make sure you did all your manual clean-up etc – but in a world where you have to consider the possibility of exceptions anyway, and the garbage collector handles most of the cleanup, with try/finally handling the rest, I find there are a lot of cases where insisting on a single exit point makes the code significantly harder to read – particularly around cases where you can determine the result right at the start of the method (e.g. “if the input string is empty, the result is always going to be 0 – so just return it there).

EDIT: Just to be clear, in your situation I don’t think it makes much difference. But this is the kind of code where single point of return gets messy:

 public int DoSomething(string input1, string input2)
 {
     // First simple case
     if (input1 == null || input2 == null)
     {
         return -1;
     }

     // Second simple case
     int totalLength = input1.Length + input2.Length;
     if (totalLength < 10)
     {
         return totalLength;
     }

     // Imagine lots of lines here, using input1, input2 and totalLength
     // ...
     return someComplicatedResult;
 }

With a single point of return, this would become:

 public int DoSomething(string input1, string input2)
 {
     int ret;

     // First simple case
     if (input1 == null || input2 == null)
     {

         ret = -1;
     }
     else
     {
         // Second simple case
         int totalLength = input1.Length + input2.Length;
         if (totalLength < 10)
         {
             ret = totalLength;
         }
         else
         {
             // Imagine lots of lines here, using input1, input2 and totalLength
             // ...
             ret = someComplicatedResult;
         }
     }
     return ret;
 }

I would definitely rather read the first form than the second:

• More nesting generally makes code harder to understand. It’s hard to remember where you’ve got to
• In the first form, you can clearly tell – without reading any more code – that if you get to the base cases, you’re done. There’s not going to be any side effect after the complicated code; we’re just going to return. In the second code, you have to mentally skip over the “else” blocks to work out what’s happening. You’re looking over more code to work out the path.