What is the conditional attribute?

The conditional attribute enables including/omitting methods calls during compilation depending on compilation symbols. For example, we can condition that a specific log method calls will be included only when we compile in debug. The compiler in this case will omit the calls to the method. Looking at the next code:

public class Logger
{
    [Conditional("DEBUG")]
    public void LogDebugMessage(string str)
    {

    }
}

And the code calling it:

class MyClass
{
    private readonly Logger logger = new Logger();

    public void Foo()
    {
        logger.LogDebugMessage("Foo");
    }
}

We expect the compiler to omit the body of Foo(). As we can see with a disassembler this is exactly what happens:

.method public hidebysig instance void  Foo() cil managed
{
  // Code size       1 (0x1)
  .maxstack  8
  IL_0000:  ret
} // end of method MyClass::Foo

How method arguments are treated?

Temp variable assignment optimization

Regardless the conditional attribute, in release mode the compiler performs many optimization which one of them is skipping local variable assignment. You’re most likely to notice it when you assign a value into a local variable and pass it to a method as an argument (while this is the only variable usage). For example:

public void Foo()
{
    var foo = "Foo";
    logger.LogDebugMessage(foo);
}

Translates into:

0527C028  mov         edx,dword ptr ds:[2EE78B0h]  	// Load the string address
0527C02E  mov         ecx,dword ptr [ecx+4]             // Load the logger instance
0527C031  cmp         dword ptr [ecx],ecx  		// Null check
0527C033  call        dword ptr ds:[50C5BD8h]  		// Call LogDebugMessage
0527C039  ret  

While:

public void Foo()
{
    logger.LogDebugMessage("Foo");
}

Translates into:

0552C028  mov         ecx,dword ptr [ecx+4]  		// Load the logger instance
0552C02B  mov         edx,dword ptr ds:[31478B0h]  	// Load the string address
0552C031  cmp         dword ptr [ecx],ecx  		// Null check
0552C033  call        dword ptr ds:[5375C30h]  		// Call LogDebugMessage
0552C039  ret  

Which are basically the same. So in case we’re not using the conditional attribute we shouldn’t care about local assignment. We can expect to have no difference in runtime.

Temp variable sent to omitted call optimization?

So an interesting question is what happens to an argument we’re about to send to a conditional method? If call to LogDebugMessage are omitted, what should we expect in this case:

public void Foo()
{
    var method = MethodBase.GetCurrentMethod().Name;
    logger.LogDebugMessage(method);
}

And in this case:

public void Foo()
{
    logger.LogDebugMessage(MethodBase.GetCurrentMethod().Name);
}

The answer can be easily found by looking at the methods IL. The first version with temp assignment to a variable compiles into:

.method public hidebysig instance void  Foo() cil managed
{
  // Code size       12 (0xc)
  .maxstack  8
  IL_0000:  call       class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetCurrentMethod()
  IL_0005:  callvirt   instance string [mscorlib]System.Reflection.MemberInfo::get_Name()
  IL_000a:  pop
  IL_000b:  ret
} // end of method MyClass::Foo

While the second version compiles into:

.method public hidebysig instance void  Foo() cil managed
{
  // Code size       1 (0x1)
  .maxstack  8
  IL_0000:  ret
} // end of method MyClass::Foo

As we can see, in this case the argument was not even evaluated and the whole statement was omitted from the IL. Meaning that in this case, inlining the variable would have influence on the performance. It didn’t happen by chance, this is the defined behavior of the compiler as stated in the Conditional attribute documentation:

“If the symbol is defined, the call is included; otherwise, the call (including evaluation of the parameters of the call) is omitted.”

Conclusion

The most common scenario in which the conditional attribute is involved is logging. Since the main advantage of omitting the logs is usually to avoid performance hit in production it is important to take into consideration the price of evaluating the arguments values. The simplest solution is to inline the variable. This can be done easily when the argument is string.Format() or similar. In case it is more complicated or unreadable it can always be solved by preprocessor directive such as #if.