Comprobando si un método devuelve falso: ¿asignar el resultado a la variable temporal o poner la invocación del método directamente en condicional?

¿Es una buena práctica llamar a un método que devuelve valores verdaderos o falsos en una declaración if?

Algo como esto:

private void VerifyAccount()
{
    if (!ValidateCredentials(txtUser.Text, txtPassword.Text))
    {
        MessageBox.Show("Invalid user name or password");
    }
}

private bool ValidateCredentials(string userName, string password)
{
    string existingPassword = GetUserPassword(userName);
    if (existingPassword == null)
        return false;

    var hasher = new Hasher { SaltSize = 16 };
    bool passwordsMatch = hasher.CompareStringToHash(password, existingPassword);

    return passwordsMatch;
}

o es mejor almacenarlos en una variable y luego compararlos con valores if if this como este

bool validate = ValidateCredentials(txtUser.Text, txtPassword.Text);
if(validate == false){
    //Do something
}

No solo me refiero a .NET, me refiero a la pregunta en todos los lenguajes de programación, simplemente sucede que utilicé .NET como ejemplo

Como con todas estas cosas, depende.

Si no va a utilizar el resultado de su llamada, ValidateCredentialsentonces no es necesario (excepto para fines de depuración) almacenar el resultado en una variable local. Sin embargo, si hace que el código sea más legible (y, por lo tanto, más fácil de mantener) para que una variable vaya con eso.

El código no será mensurablemente menos eficiente.

¿Por qué usar una variable adicional? Prefiero usar el primer enfoque, es más legible y simple.

¿Es una buena práctica llamar a un método que devuelve valores verdaderos o falsos en una declaración if?

Sí, si el condicional no es lo suficientemente simple como para alinearlo y hacer que sea legible.

o es mejor almacenarlos en una variable y luego compararlos con valores if if this como este

Solo debe hacer esto si está utilizando el valor en varios lugares o si lo necesita para que el código sea más legible. De lo contrario, la asignación a una variable es innecesaria. El código innecesario es, en el mejor de los casos, un desperdicio y, en el peor, una fuente de un defecto.

Vamos a ver...

Porque todo se trata de KISS , no hay necesidad de crear una variable adicional cuando puede prescindir de ella. Además, no hay necesidad de escribir más ... cuando no hay necesidad.

Pero luego, porque SECO , si luego estaba llamando ValidateCredentialsy se encuentra escribiendo ValidateCredentials(txtUser.Text, txtPassword.Text), sabe que debería haber creado una variable adicional.

Sí, generalmente está bien usar métodos como si fueran condiciones. Sin embargo, es útil si el nombre del método indica que el método devuelve un valor bool; por ejemplo CanValidateCredentials. En los lenguajes de estilo C, este método a menudo toma la forma de los prefijos Is y Can, y en Ruby con el '?' sufijo.

Hay otra preocupación que aún no se ha señalado: la evaluación de cortocircuito . ¿Cuál es la diferencia entre estos dos fragmentos de código?

Ej # 1:

if(foo() && bar() && baz())
{
    quz();
}

Ej # 2:

bool isFoo = foo();
bool isBar = bar();
bool isBaz = baz();
if(isFoo && isBar && isBaz)
{
    quz();
}

Parece que estos dos fragmentos de código hacen lo mismo, pero si su idioma admite la evaluación de cortocircuito, estos dos fragmentos son diferentes. La evaluación de cortocircuito significa que el código evaluará el mínimo que necesita para pasar o fallar una condición. Si el ejemplo # 1, si foo () devuelve falso, bar () y baz () ni siquiera se evalúan. Esto es útil si baz () es una llamada de función de larga duración porque puede omitirla si foo () devuelve falso o foo () devuelve verdadero y bar () devuelve falso.

Este no es el caso en el ejemplo # 2. foo (), bar () y baz () siempre se evalúan. Si espera que bar () y baz () exhiban efectos secundarios, tendrá problemas con el Ejemplo # 1. El ejemplo # 1 anterior es en realidad equivalente a esto:

Ej # 3:

if(foo())
{
    if(bar())
    {
        if(baz())
        {
            quz();
        }
    }
}

Tenga en cuenta estas diferencias en su código al elegir entre los ejemplos 1 y 2.

Ampliando un poco el tema de la legibilidad ...

Se me ocurren dos buenas razones para almacenar el resultado en una variable:

1. Si va a usar la condición más de una vez, guardarla en una variable significa que solo tiene que llamar a la función una vez. (Esto supone que el valor almacenado sigue siendo válido; si necesita volver a probarlo, por supuesto, esto no se aplica).

2. Si almacenarlo en una variable mejora la legibilidad al darle a la condición un nombre más significativo que el que se ve en la llamada a la función.

Por ejemplo, esto:

bool foo_is_ok = is_ok(foo);
if (foo_is_ok) ...

no ayuda a la legibilidad, pero esto:

bool done_processing = feof(file1) && feof(file2);
if (done_processing) ...

probablemente sí, ya que no es obvio de inmediato que eso feof(file1) && feof(file2)significa que hemos terminado el procesamiento.

los passwordsMatch variable en la pregunta es probablemente un mejor ejemplo que el mío.

Las variables de un solo uso son útiles si dan un nombre significativo a algún valor. (Por supuesto, esto es para beneficio del lector humano).