Writing if..else construct without long condition checks to increase maintainability Should writing if..else construct in the following manner be flagged for correction in peer code review? 

Existing Code

bool userInstanceHasTransactions = userInstance != null &amp;&amp; userInstance.Transactions &gt; 0;
if(userInstanceHasTransactions) {
   //Processing logic here
} else {
  //Some other processing here
}


Flagged to change as

if(userInstance != null &amp;&amp; userInstance.Transactions &gt; 0) {
   //Processing logic here
} else {
  //Some other processing here
}


I have observed code of this kind in C#, but I believe language really does not mattter for this question.

I noticed there are lot of if..else construct written in this manner. Will too many if..else construct in this manner impact size of the binary file (dll or exe)?

Is it correct to say writing if..else construct in the manner depicted above increases readability?
Replace Temp variables with queries

It's a primary refactoring technique championed by Fowler in his book Refactoring. That as well as the second technique of extracting methods from complex/long code dramatically improves code readability. Please see below for examples:

public void Testc()
{            
    // The code that you've suggested as the first option
    // makes the if statement more readable and it should be preserved
    // over the complicated code within the if statement IMO: i.e. if(userInstance != null &amp;&amp; userInstance.Transactions &gt; 0)
    // but it introduces the problem of temporary variables - which, when refactoring
    // should probably be replaced with a query, as Martin Fowler suggests,
    // unless you have cogent reasons to preserve them as a temporary variables 
    // (i.e. for performance reasons). If that's the case, Fowler suggests
    // to still replace the temporary variable with a query, and further down the line
    // to THEN start thinking about optimisation. This might force you back to using temporary
    // variables.

    // Summary:
    // So Fowler suggests to replace the logic with a query. And Then to
    // start thinking about optimisation if required
    // so it would look something like this:

    if (UserInstanceHasTransactions())
    {
        //Processing logic here
    }
    else
    {
        //Some other processing here
    }
}

public bool UserInstanceHasTransactions()
{
    return userInstance != null &amp;&amp; userInstance.Transactions &gt; 0;
}


As Volundi points out sometimes the userInstance might itself be a temporary variable. if that's the case you might have to do something like this:

public bool UserInstanceHasTransactions(userInstance )
{
    return userInstance != null &amp;&amp; userInstance.Transactions &gt; 0;
}


And you could call it like this:

if (UserInstanceHasTransactions(userInstance))
{
    //Processing logic here
}
else
{
    //Some other processing here
}


Above all the important thing is to preserve readability, because your code will be read many more times than it is edited. If the userInstance is a temporary variable then you might want to consider refactoring all those instances as a query method and as Fowler suggests, if performance is not a problem.