C # condicional Y (&&) O (||) precedencia

Si realmente quieres asustarlo prueba:{[18]]}

bool result = True() | False() && False();

Console.WriteLine("-----");
Console.WriteLine(result);

static bool True()
{
    Console.WriteLine(true);
    return true;
}

static bool False()
{
    Console.WriteLine(false);
    return false;
}

Esto se imprimirá:

True
False
False
-----
False

Editar:

En respuesta al comentario:

En C#, | es un operador lógico que realiza la misma lógica booleana que ||, pero no hace cortocircuito. También en C#, el operador | tiene mayor precedencia que || y &&.

Al imprimir los valores, puede ver que si utilizo el operador típico ||, solo se imprimiría el primer True - seguido por el resultado de la expresión que habría sido True también.

Pero debido a la mayor precedencia de |, el true | false se evalúa primero (lo que resulta en true) y luego ese resultado es && ed con false para producir false.

No estaba tratando de mostrar el orden de la evaluación, solo el hecho de que la mitad correcta del | fue evaluado período cuando normalmente no sería :)

No lo demuestras con código sino con lógica. AND es multiplicación booleana mientras que OR es adición booleana. Ahora, ¿cuál tiene mayor precedencia?

¿No conseguirías esto lo que buscas? O tal vez me estoy perdiendo algo...

bool result = true || false && false;

False / / true & & true

Rinde: verdadero

False & & true / / true

Rinde: verdadero

No puede simplemente mostrar el resultado final cuando sus expresiones booleanas están siendo cortocircuitadas. Aquí hay un fragmento que resuelve su caso.

Se basa en la implementación de & y / operadores utilizados por & & y|/, como se indica en MSDN 7.11 Operadores lógicos condicionales

public static void Test()
{
    B t = new B(true);
    B f = new B(false);

    B result = f || t && f;

    Console.WriteLine("-----");
    Console.WriteLine(result);
}

public class B {
    bool val;
    public B(bool val) { this.val = val; }
    public static bool operator true(B b) { return b.val; }
    public static bool operator false(B b) { return !b.val; }
    public static B operator &(B lhs, B rhs) { 
        Console.WriteLine(lhs.ToString() + " & " + rhs.ToString());
        return new B(lhs.val & rhs.val); 
    }
    public static B operator |(B lhs, B rhs) { 
        Console.WriteLine(lhs.ToString() + " | " + rhs.ToString());
        return new B(lhs.val | rhs.val); 
    }
    public override string ToString() { 
        return val.ToString(); 
    }
}

La salida debe mostrar que && se evalúa primero antes de ||.

True & False
False | False
-----
False

Para mayor diversión, pruébelo con result = t || t && f y vea qué sucede con los cortocircuitos.