How are compiled method calls that return a value?

Question

If I have a method which returns a value (for example the Remove method of Dictionary class returns a bool), what happens if I do not assign the return value to a variable? In other words, if I write dictionary.Remove("plugin-01"); without assigning the result to a bool variable, what are the differences in compilation with respect to bool b = dictionary.Remove("plugin-01");?

Answer 1

Let's look at a simple example and the IL code it is producing (courtesy of LinqPad)

void Main()
{
    Bar();
    Baz();
}

bool Bar()
{
  return true;
}

void Baz()
{
  Console.WriteLine("placeholder");
}

This produces the following IL:

IL_0000:  ldarg.0     
IL_0001:  call        UserQuery.Bar
IL_0006:  pop          //remove current value from evaluation stack
IL_0007:  ldarg.0     
IL_0008:  call        UserQuery.Baz


Bar:
IL_0000:  ldc.i4.1    
IL_0001:  ret    

Baz:
IL_0000:  ldstr       "placeholder"
IL_0005:  call        System.Console.WriteLine
IL_000A:  ret   

You can see Bar is called and then a pop to remove the boolean return value from the evaluation stack - it's going nowhere. I had to update the example to include another method call to Baz() otherwise the pop would not be emitted, since the program ends.

Now let's look at a case where we actually use the return value:

void Main()
{
    bool foo = Bar();
    Console.WriteLine(foo);
}

bool Bar()
{
  return true;
}

This produces the following IL:

IL_0000:  ldarg.0     
IL_0001:  call        UserQuery.Bar
IL_0006:  stloc.0    //pops current value from evaluation stack, stores in local var
IL_0007:  ldloc.0     
IL_0008:  call        System.Console.WriteLine

Bar:
IL_0000:  ldc.i4.1    
IL_0001:  ret 

Ignore the System.Console.WriteLine part which is everything after and including IL_007 - just had to add it so the compiler does not optimize away the use of the variable. You see that the result of the Bar method call is popped from the evaluation stack and stored in the local variable foo. That is the difference - either a pop, which grabs and drops the return value or a stloc.0 to assign the result to a variable.

So if you do not need the results of a method call you should just ignore the result. Even if you assign the result to a variable and that variable is never used, the compiler might completely optimize away the variable and the assignment - at least in release mode (in debug mode most optimizations are disabled to improve your debugging experience).