Perché c'è una variazione di cortocircuito O di cortocircuito o di cortocircuito di quell'operatore in C #?

Periodicamente, mi chiedo questo:

L'OR di cortocircuito restituirebbe sempre lo stesso valore dell'operatore OR non cortocircuitato?

Mi aspetto che il corto circuito O valuterà sempre più rapidamente. Quindi, l'operatore OR non cortocircuitato è stato incluso nel linguaggio C # per coerenza?

Cosa mi sono perso?

Entrambi gli operandi erano pensati per cose diverse, provenienti da C che non aveva un tipo booleano. La versione di corto circuito || funziona solo con i booleani, mentre la versione non in corto circuito | funziona con tipi integrali, eseguendo un bit per bit o. È capitato di funzionare come un'operazione logica non di corto circuito per i booleani che sono rappresentati da un singolo bit, essendo 0 o 1.

http://en.wikibooks.org/wiki/C_Sharp_Programming/Operators#Logical

|(bitwise-or) deve essere non in cortocircuito per tipi come int. Questo perché in quasi tutti i casi è necessario calcolare entrambi i lati di |un'espressione per calcolare il risultato corretto. Ad esempio, qual è il risultato 7 | f(x)?

Se f(x)non viene valutato, non è possibile dirlo.

Inoltre, sarebbe incoerente mettere in corto circuito questo operatore boolquando non è in cortocircuito int. A proposito, penso di non aver mai usato |intenzionalmente confronti logici, trovando molto scomodo parlare di |operatore logico.

|| tuttavia è per confronti logici, in cui la valutazione del corto circuito funziona correttamente.

Lo stesso vale anche per C e C ++, dove si trova l'origine di tali operatori.

Ciò è corretto, l'operatore OR di corto circuito (||) restituirà sempre lo stesso valore dell'operatore OR di corto circuito (|). (*)

Tuttavia, se il primo operando è vero, l'operatore in cortocircuito non farà la valutazione del secondo operando, mentre l'operatore non in cortocircuito farà sempre la valutazione di entrambi gli operandi. Ciò può avere un impatto sulle prestazioni e talvolta sugli effetti collaterali.

Quindi, c'è un uso per entrambi: se ti preoccupi delle prestazioni e la valutazione del secondo operando non produce effetti collaterali (o se non ti importa di loro), allora usa l'operatore di cortocircuito . Ma se per qualche motivo hai bisogno degli effetti collaterali del secondo operando, allora dovresti usare l'operatore non in cortocircuito.

Un esempio in cui è necessario utilizzare l'operatore non in corto circuito:

if( write_customer_to_database() != SUCCESS |
    write_supplier_to_database() != SUCCESS |
    write_order_to_database() != SUCCESS )
{
    transaction_rollback();
}

(*) Ad eccezione di alcuni scenari realmente perversi in cui la valutazione del primo operando su false causa, per effetto collaterale, il secondo operando da valutare su true anziché su false.

Ci sarebbero 2 motivi per usare la variante senza cortocircuito:

1. mantenendo gli effetti collaterali (ma è più chiaro codificare con una variabile temporanea)

2. contrastare gli attacchi di temporizzazione evitando il fork nel cortocircuito (questo potrebbe persino migliorare l'efficienza di runtime se il secondo operando è una variabile ma che è comunque una micro-ottimizzazione che il compilatore può fare comunque)

se la clausola di destra dell'operatore ha un effetto collaterale e il programmatore intendeva che voleva che si verificassero entrambi gli effetti collaterali prima di verificarne il valore di ritorno.