Equivalente di Visual Basic e And Or in C#?

Question

So che AndAlso equivale a && e OrElse equivale a ||. Ma qual è il modo più pulito per ottenere l'equivalente di Visual Basic And e Or in C#?

Ad esempio, considerare il seguente codice VB.NET. Il metodo ValidateForControl esegue alcune convalida e restituisce se lo stato del controllo specificato è valido. L'intero modulo di input è valido se tutti i controlli sono validi. Tuttavia, ogni controllo deve essere validato individualmente anche se uno non è valido (il che richiede che l'operatore non cortocircuiti). L'operatore And di Visual Basic è perfetto per questa situazione, ma sfortunatamente non esiste un operatore equivalente in C# per quanto ne so (&& cortocircuiti).

Return _ 
    Me.ValidateForControl(Me.firstNameTextBox) And 
    Me.ValidateForControl(Me.middleNameTextBox) And 
    Me.ValidateForControl(Me.lastNameTextBox) And 
    Me.ValidateForControl(Me.streetAddressTextBox) And 
    Me.ValidateForControl(Me.cityTextBox) And 
    Me.ValidateForControl(Me.stateComboBox) And 
    Me.ValidateForControl(Me.zipCodeMaskedTextBox) And 
    Me.ValidateForControl(Me.phoneMaskedTextBox) And 
    Me.ValidateForControl(Me.emailAddressTextBox) And 
    Me.ValidateForControl(Me.checkInDateTimePicker) And 
    Me.ValidateForControl(Me.checkOutDateTimePicker) And 
    Me.ValidateForControl(Me.rentalUnitsGroupBox) 

Inoltre, per booleani, è ^ in C# equivalenti a Xor in Visual Basic?

Answer 1

And ->&

Or ->|

Sì, Xor ->^

Answer 2

È sufficiente utilizzare & per And e | per Or. Entrambi ^ e != sono equivalenti a Xor (e l'altro), quando entrambi gli operandi sono booleani.

Answer 3

Usa & e |.

Answer 4

In questo caso, è possibile utilizzare il bitwise-and operator (&):

return 
    this.ValidateForControl(this.firstNameTextBox) & 
    this.ValidateForControl(this.middleNameTextBox) & 
    this.ValidateForControl(this.lastNameTextBox) & 
    this.ValidateForControl(this.streetAddressTextBox) & 
    this.ValidateForControl(this.cityTextBox) & 
    this.ValidateForControl(this.stateComboBox) & 
    this.ValidateForControl(this.zipCodeMaskedTextBox) & 
    this.ValidateForControl(this.phoneMaskedTextBox) & 
    this.ValidateForControl(this.emailAddressTextBox) & 
    this.ValidateForControl(this.checkInDateTimePicker) & 
    this.ValidateForControl(this.checkOutDateTimePicker) & 
    this.ValidateForControl(this.rentalUnitsGroupBox); 

E sì, XOR è farro ^ in C# (come nella maggior parte delle lingue C-like).

Answer 5

Il MSDN documentation for && ha un esempio che mostra sia "regolare AND" & e "cortocircuito AND" &&.

Assicurati di commentare il tuo uso di & come molti programmatori C# si aspetteranno && con bool s.

---

Si potrebbe anche scrivere un metodo di estensione And

static class BooleanExtensions 
{ 
    public static bool And(this bool lhs, bool rhs) 
    { 
     return lhs & rhs; 
    } 
} 

anche se probabilmente stai meglio solo attaccare con il & sintassi nativa. Si noti che un metodo di estensione AndAlso non sarebbe utile in quanto l'argomento rhs verrà valutato come parte della chiamata al metodo.

Answer 6

Storicamente (lingua B, precursore di C), operatori bit per bit (& |) è stato utilizzato come operatore logico, ma dal momento che non fa corto circuito, hanno rettificare rapidamente la lingua e ha introdotto quelle corte circuito (& & ||)

Infatti, a causa di ciò, la precedenza degli operatori bit a bit continua a mantenere la stessa associatività dell'operatore fino ad ora. Fino ad ora, l'operatore bit a bit (come il suo operatore logico) si lega ai confronti anziché all'espressione.

Caso in questione, questo operatore associatività ...

if (A + B == C) 

... non è seguito da questa:

if (A & B == C) 

Il secondo codice, A viene valutata in modo indipendente e B == C sono valutate insieme. Ecco perché è necessario inserire una parentesi per gli operatori bit a bit per ottenere la stessa associatività dell'operatore delle operazioni matematiche.

if ((A & B) == C) 

linguaggi C di ispirazione, non sono stati risparmiati, i progettisti di Java e C# potrebbe rompere la tradizione e dare gli operatori bit per bit lo stesso operatore associatività operatori come aritmetici. Ma non l'hanno fatto, quindi il grande numero di codice C può essere riutilizzato in quelle lingue.

Prima, non riesco a capire perché & e | non si comporta come + -/*.

Per rispondere alla tua domanda, basta usare operatore bit a bit:

protected void Page_Load(object sender, EventArgs e) 
    { 

     bool isValid = A() & B(); 

     Response.Output.Write("<br>Is Valid {0}", isValid); 

    } 

    bool A() 
    { 
     Response.Write("<br>TestA"); 
     return false; 
    } 

    bool B() 
    { 
     Response.Write("<br>TestB"); 
     return true; 
    }