c# which is the better way to declare two parameters

Question

I have a very quick question about the best way to use two variables. Essentially I have an enum and an int, the value for which I want to get within several ifs. Should I declare them outside the if's or inside - consider the following examples:

e.g.a:

public void test() {
    EnumName? value = null;
    int distance = 0;

     if(anotherValue == something) {
        distance = 10;
        value = getValue(distance);
     }
     else if(anotherValue == somethingElse) {
        distance = 20;
        value = getValue(distance);
     }


    if (value == theValueWeWant){
      //Do something
 }

OR

e.g.2

public void test() {

     if(anotherValue == something) {
        int distance = 10;
        EnumType value = getValue(distance);
        if (value == theValueWeWant){
           //Do something
     }
     else if(anotherValue == somethingElse) {
        int distance = 20;
        EnumType value = getValue(distance);
        if (value == theValueWeWant){
            //Do something
     }

 }

I am just curious which is best? or if there is a better way?

both are different scenarios the first example needs the variables outside of if statement while the second example the variables are not needed outside of if statement scope — Zaki, Jul 24 '13 at 16:17

score 3 · Answer 1 · answered Jul 24 '13 at 16:18

Purely in terms of maintenance, the first code block is better as it does not duplicate code (assuming that "Do something" is the same in both cases).

In terms of performance, the difference should be negligible. The second case does generate twice as many locals in the compiled IL, but the JIT should notice that their usage does not overlap and optimize them away. The second case is also going to cause emission of the same code twice (if (value == theValueWeWant) { ...), but this should also not cause any significant performance penalty.

(Though both aspects of the second example will cause the compiled assembly to be very slightly larger, more IL does not always imply worse performance.)

Tory · Answer 2 · 2013-07-24T16:37:06.770

Both examples do two different things:

Version 1 will run the same code if you get the desired value, where as Version 2 will potentially run different code even if you get the desired value.

There's a lot of possible (micro)optimizations you could do.

For Example, if distance is only ever used in getValue(distance), you could get rid of it entirely:

 /*Waring, micro-optimization!*/
 public void test() {

      EnumType value = getValue((anotherValue == something) ? 10 : (anotherValue == somethingElse) ? 20 : 0);
      if (value == theValueWeWant){
  //Do something
      }
 }

score 0 · Answer 3 · answered Jul 24 '13 at 16:17

If you wish to use those later on, then g for the second method. Those variables will be lost as soon as they're out of scope.

Even if you don't want to use them later, declaring them before the if's is something you should do, to avoid code repetition.

score 0 · Answer 4 · answered Jul 24 '13 at 16:17

This question is purely a matter of style and hence has no correct answer, only opinions

The C# best practice is generally to declare variables in the scope where they are used. This would point to the second example as the answer. Even though the types and names are the same, they represent different uses and should be constrained to the blocks in which they are created.

c# which is the better way to declare two parameters

4 Answers4