Performance and static method versus public method

Question

I have a helper method that takes a begin date and an end date and through certain business logic yields an integer result. This helper method is sometimes called in excess of 10,000 times for a given set of data (though this doesn't occur often).

Question: Considering performance only, is it more efficient to make this helper method as a static method to some helper class, or would it be more gainful to have the helper method as a public method to a class?

Static method example:

// an iterative loop
foreach (var result in results) {
    int daysInQueue = HelperClass.CalcDaysInQueue(dtBegin, dtEnd);
}

Public member method example:

// an iterative loop
HelperClass hc = new HelperClass();
foreach (var result in results) {
    int daysInQueue = hc.CalcDaysInQueue(dtBegin, dtEnd);
}

Thanks in advance for the help!

Answer 1

When you call an instance method the compiler always invisibly passes one extra parameter, available inside that method under this name. static methods are not called on behalf of any object, thus they don't have this reference.

I see few benefits of marking utility methods as static :

• small performance improvement, you don't pay for a reference to this which you don't really use. However I doubt you will ever see the difference.

• convenience - you can call static method wherever and whenever you want, the compiler is not forcing you to provide an instance of an object, which is not really needed for that method

• readability : instance method should operate on instance's state, not merely on parameters. If it's an instance method not needing an instance to work, it's confusing.

Answer 2

The difference in performance here is effectively nothing. You will have a hard time actually measuring the difference in time (and getting over the "noise" of other stuff going on with your CPU), that's how small it will be.

Unless you happen to go and perform a whole bunch of database queries or read in several gigabytes of info from files in the constructor of the object (I'm assuming here that' it's just empty) it will have a fairly small cost, and since it's out of the loop it doesn't scale at all.

You should be making this decision based on what logically makes sense, not based on performance, until you have a strong reason to believe that there is a significant, and necessary performance gain to be had by violating standard practices/readability/etc.

In this particular case your operation is logically 'static'. There is no state that is used, so there is no need to have an instance of the object, as such the method should be made static. Others have said that it might perform better, which is very possibly true, but that shouldn't be why you make it static. If the operation logically made sense as an instance method you shouldn't try to force it into a static method just to try to get it to run faster; that's learning the wrong lesson here.

Answer 3

Just benchmark it :) In theory a static method should be faster since it leaves out the virtual call overhead but this overhead might not be significant in your case (but I'm not even sure what language the example is in). Just time both loops with a large enough number of iterations for it to take a minute or so and see for yourself. Jut make sure you use non-trivial data so your compiler doesn't optimize the calls out.

Answer 4

Based on my understanding, it would be more beneficial for performance to make it a static method. This means that there isn't an instance of the object created, although the performance difference would be negligible, I think. That is the case if there isn't some data that has to be recreated every time you call the static function, which could be stored in the class object.

Answer 5

You say 'considering performance only'. In that case you should fully focus on whats inside

HelperClass.CalcDaysInQueue(dtBegin, dtEnd);

And not on the 0.0001% of runtime spent in calling that routine. If it's a short routine the JIT compiler will inline it anyway and in that case there will be NO performance difference between the static and instance method.