Method with just one line will hit performance?

Question

In a code ValidateRequestmethod is defined

    private bool ValidateRequest()
    {
        return _doc != null;
    }

This method is called from everywhere I want to check if _doc is null. This method has been used 5 times in a cs file.

Performance point of view is it advisable to define a method with just a line? I think before calling this method everything from called will be pushed on stack and after it will be pulled from stack.

Any thoughts?

=== Edit ====

I am using .NET version 3.5

Have you profiled the app and verified this is a real bottleneck? — Kirk Woll, Apr 24 '12 at 13:53
How many times per second will it be executed, roughly? If 10^9, care about it. If 10^6, don't. — Mike Dunlavey, Apr 24 '12 at 17:17

score 7 · Answer 1 · answered Apr 24 '12 at 13:54

7

Don't bother with it. The compiler will probably inline the method as the corresponding IL is quite short.

If that method helps with code maintainability, as it communicates intention go on with it

answered Apr 24 '12 at 13:54

MikeSW

16,140
3
39
53

score 7 · Answer 2 · answered Apr 24 '12 at 13:58

It's highly unlikely that moving a single line into a method will have a significant impact on your application. It's actually quite possible that this will have no impact as the JIT could choose to inline such a function call. I would definitely opt for keeping the check in a separate method unless a profiler specifically showed it to be a problem.

Focus on writing code that is clear and well abstracted. Let the profiler guide you to the real performance problems.

score 5 · Answer 3 · edited May 23 '17 at 11:48

5

As always: when you have doubts, benchmark!
And when you benchmark, do it in release mode, otherwise you're not benchmarking with compiler optimizations.

After that, if it does indeed impact performance, you can inline it with NGen.
This SO post talks about it.

edited May 23 '17 at 11:48

Community

1
1

answered Apr 24 '12 at 13:54

Louis Kottmann

16,268
4
64
88

score 1 · Accepted Answer · answered Apr 24 '12 at 14:05

1

ok, so this is just from LinqPad, and not I guess a definitive answer, but the following code produced a minuscule discrepancy:(00:00:00.7360736 vs 00:00:00.0740074)

void Main()
{
    var starttime = DateTime.Now;
    for (var i = 0; i < 1000000000; i++)
    {
        if (ValidateRequest()) continue;
    }
    var endtime = DateTime.Now;
    Console.WriteLine(endtime.Subtract(starttime));

    starttime = DateTime.Now;
    for (var i = 0; i < 100000000; i++)
    {
        if (_doc != null) continue;
    }
    endtime = DateTime.Now;
    Console.WriteLine(endtime.Subtract(starttime));
}

private object _doc = null;

private bool ValidateRequest()
    {
        return _doc != null;
    }

answered Apr 24 '12 at 14:05

pms1969

3,354
1
25
34

That miniscule discrepancy is a factor of 10! – AppFzx Feb 15 '13 at 15:56
1

so true, but it looks like I just missed a zero off the second for loop. making it a factor of 10 out. doh! – pms1969 Mar 05 '13 at 07:43
you're right. I looked at that to double check that wasn't where it wasn't coming from and still missed it. – AppFzx Mar 05 '13 at 13:59

Method with just one line will hit performance?

4 Answers4