Equivalente de E y O de Visual Basic en C#?

Question

Sé que AndAlso es equivalente a && y OrElse es equivalente a ||. Pero ¿cuál es la forma más limpia de obtener el equivalente de Visual Basic And y Or en C#?

Por ejemplo, considere el siguiente código VB.NET. El método ValidateForControl realiza una validación y devuelve si el estado del control especificado es válido. El formulario de entrada completo es válido si todos los controles son válidos. Sin embargo, cada control debe validarse individualmente, incluso si uno no es válido (lo que requiere que el operador no se cortocircuite). El operador And de Visual Basic es perfecto para esta situación, pero desafortunadamente no hay un operador equivalente en C# hasta donde yo sé (&& cortocircuitos).

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) 

Además, para booleanos, es ^ en C# equivalentes a Xor en Visual Basic?

Answer 1

And ->&

Or ->|

Sí, Xor ->^

Answer 2

Usted acaba de usar & para And y | para Or. Tanto ^ como != son equivalentes a Xor (y entre ellos), cuando ambos operandos son booleanos.

Answer 3

Uso & y |.

Answer 4

En este caso, se puede utilizar el 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); 

Y sí, XOR es deletreado ^ en C# (como en la mayoría de lenguajes de programación como C).

Answer 5

La MSDN documentation for && tiene una muestra que muestra "Y regular" & y "cortocircuito Y" &&.

Asegúrese de comentar el uso de & ya que la mayoría de los programadores de C# esperan && con bool s.

---

También podría escribir un método de extensión And

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

aunque es probable que estés mejor simplemente pegando con la sintaxis nativa &. Tenga en cuenta que un método de extensión AndAlso no sería útil ya que el argumento rhs se evaluaría como parte de la llamada al método.

Answer 6

Históricamente (lengua B, precursor C), operadores de bits (& |) fue utilizado como operador lógico, pero ya que no hace corto circuito, rápidamente rectificar el lenguaje y las introdujo en cortocircuito (& & ||)

de hecho, a causa de ello, el nivel de bit-operadores preferencia aún llevan la misma asociatividad de operadores hasta ahora. Que hasta ahora, el operador bit a bit (como su operador lógico) se une a las comparaciones en lugar de en la expresión.

El caso en cuestión, esta asociatividad de operadores ...

if (A + B == C) 

... no es seguido por:

if (A & B == C) 

En el segundo código, A se evalúa de forma independiente y se evalúan B == C juntos. Es por eso que debemos poner paréntesis para que los operadores bit a bit logren la misma asociatividad del operador que las operaciones matemáticas.

if ((A & B) == C) 

lenguajes C-inspirado no se libraron, los diseñadores de Java y C# podría romper la tradición y dar a los operadores bit a bit el mismo asociatividad de operadores como operadores aritméticos. Pero no lo hicieron, por lo que la gran base de código C puede ser reutilizada en esos idiomas.

Antes, no entiendo por qué & y | no se comportan igual que + -/*.

Para responder a su pregunta, sólo tiene que utilizar el operador 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; 
    }