CODEWITHSUNDEEP
c#optimizationcoding-style
Pectus Excavatum
Pectus Excavatum

Reputation: 3785

c# which is the better way to declare two parameters

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?

Upvotes: 0

Views: 89

Answers (4)

Tory
Tory

Reputation: 520

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
      }
 }

Upvotes: 1

cdhowie
cdhowie

Reputation: 169291

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.)

Upvotes: 3

JaredPar
JaredPar

Reputation: 755269

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.

Upvotes: 0

Geeky Guy
Geeky Guy

Reputation: 9379

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.

Upvotes: 0

Related Questions