Enfatize a negação

Eu estava apenas escrevendo uma declaração if com nomes de propriedades razoavelmente longos e viemos resolver esse problema.

Digamos que tenhamos uma declaração if como esta:

if(_someViewModelNameThatIsLong.AnotherPropertyINeedToCheck == someValue &&
   !_someViewModelNameThatIsLong.ThisIsABooleanPropertyThatIsImportant)
{
    //Do something
}

A segunda propriedade é do tipo booleano e não faz sentido ter a declaração como

if(boleanValue == true)

Existe uma maneira melhor de enfatizar a negação do que colocar a !frente. Para mim, parece que isso pode ser facilmente supervisionado ao ler o código e pode potencialmente causar problemas com a depuração

if(_someViewModelNameThatIsLong.NeedsMeToDoSomething(someValue))
{
    //Do something
}

E então, no objeto de modelo de exibição

public bool NeedsMeToDoSomething(string someValue)
{
    return AnotherPropertyINeedToCheck == someValue &&
        !ThisIsABooleanPropertyThatIsImportant;
}

(supondo que someValue seja uma sequência e não seja conhecida pelo objeto de modelo)

Isso não apenas enfatiza o! operador, mas o torna mais legível em geral. Agora, no método de chamada, posso ver uma condição, que deve ser bem nomeada para descrever a condição no contexto do objeto de chamada. E no objeto modelo, posso ver o que isso significa no contexto do objeto modelo.

Coloque-o em seu próprio bloco se antes de avaliar as condições menos importantes. Não apenas seria mais fácil ler sem a confusão das outras condições, mas também é a primeira condição que um programador lerá. Combine isso com a idéia já mencionada por @scrwtp para atribuir a uma variável com um nome significativo e você obtém:

var isValid = !_someViewModelNameThatIsLong.ThisIsABooleanPropertyThatIsImportant;
if( isValid ) 
{
    if( _someViewModelNameThatIsLong.AnotherPropertyINeedToCheck == someValue ) 
    {
        //Do something
    }
}

Se você estiver programando em uma linguagem de compilador, na maioria das vezes esses blocos aninhados se combinam no final de qualquer maneira, desde que você não insira código entre o externo se e o interno se, portanto, isso não afetará o desempenho nesses casos.

Se você estiver usando C / C ++, o pré-processador poderá fornecer legibilidade.

#define NOT !

if(_someViewModelNameThatIsLong.AnotherPropertyINeedToCheck == someValue &&
    NOT _someViewModelNameThatIsLong.ThisIsABooleanPropertyThatIsImportant)
{
    //Do something
}

Eu apenas extraia

`!_someViewModelNameThatIsLong.ThisIsABooleanPropertyThatIsImportant`

Em um método que retorna isso. Se você nomear esse método como NotThisIsABooleanPropertyThatIsImportant, deverá ficar bem.