Nested function calls - What's the best practice?

Question

A small thing, but I will be happy to hear what other people think about it.

Which of the 2 code segments below is the best programming practice?

var results = GetResults();

SendResults(results);

OR:

SendResults(GetResults());

I think that the first option is better, but on the other hand option 2 is less code to write (and read). What do you think?

I know it's a very basic question, but still...

Answer 1

This

var results = GetResults();
SendResults(results);

is better because it's debuggable... Try putting a breakpoin on SendResults(results) and watch the value of results.

This is so much important that in the next version of Visual Studio, the 2013 they are adding a way to see return value of functions (see for example here)

This new feature allows you to examine the return value of a function when the developer steps over or out of a function during your debugging session. This is especially useful when the returned value is not stored in a local variable. Consider the following nested function example Foo(Bar()); in this example you can now examine the return value(s) from Bar and Foo, when you step over that line.

From a compiled perspective they are normally the same. The only difference at the IL level is that a slot in the stack has some metainformation with the name of the variable (results) or is nameless.

Answer 2

In my opinion you have to always strive for clarity, so I'd much rather have:

// notice the type not var (unless it's obvious)
IEnumerable<MyClass> results = GetResults();

SendResults(results);

Answer 3

I usually go for the first option, because that way I can insert a breakpoint between the invocations of GetResults and SendResults.

It's usually not that big of a deal, if the code is in the middle of a method, but if it's in the form of:

 return Process(GetData());

the return values of both the GetData and the Process calls are not readily visible. Unless we are talking of a framework function that has no side effects and has obvious results (e.g. int.Parse) I prefer the format:

var data = GetData();
var result = Process(data);
return result;