vb.net - que - operador andalso

O frente a OrElse

Question

¿Cuál es la diferencia entre o y OrElse ?

if temp is dbnull.value or temp = 0

produce el error:

El operador ''='' no está definido para el tipo ''DBNull'' y escribe ''Entero''.

mientras que este funciona como un encanto !?

if temp is dbnull.value OrElse temp = 0

Answer 1

(Miré otras respuestas y me di cuenta de que estaba terriblemente equivocado)

El operador OrElse "realiza el cortocircuito de la disyunción lógica en dos expresiones", es decir: si el operando izquierdo es verdadero y entonces se garantiza que la expresión completa es verdadera, el operando correcto ni siquiera se evaluará (esto es útil en casos como:

string a;
//...
if (a is null) or (a = "Hi") //...

para evitar una tirada de NullReferenceException con el operando de la derecha.

Estoy sinceramente asombrado de que esto ( evaluación diferida ) no sea el comportamiento predeterminado de andy como está en C / C ++ y C # (y en muchos otros idiomas ...)

Answer 2

Este es el mismo comportamiento que con C #, donde todos usan el Coditional Or (||) y el Conditional And (&&), donde también tiene el normal O (|) y el normal And (&). Entonces, comparar C # con VB.Net es:

| => O

|| => OrElse

& => Y

&& => Y también

Los operadores booleanos condicionales son muy útiles para evitar construcciones anidadas. Pero a veces los operadores booleanos normales son necesarios para asegurar el acceso a ambas rutas de código.

Answer 3

La respuesta de Bert no es muy precisa. El ''|'' o ''&'' es operador lógico, en C #, siempre lo trata como operador de bit, por favor vea el siguiente código como ejemplo

 static void Main()
{
object a = null;
int b = 3;
if (a == null | a.ToString() == "sdffd")
{
Console.WriteLine("dddd");
}
Console.WriteLine(b | b);
Console.Read();
}

Lo siguiente es IL

 .method private hidebysig static void Main() cil managed
{
.entrypoint
// Code size 62 (0x3e)
.maxstack 3
.locals init ([0] object a,
[1] int32 b,
[2] bool CS$4$0000)
IL_0000: nop
IL_0001: ldnull
IL_0002: stloc.0
IL_0003: ldc.i4.3
IL_0004: stloc.1
IL_0005: ldloc.0
IL_0006: ldnull
IL_0007: ceq
IL_0009: ldloc.0
IL_000a: callvirt instance string [mscorlib]System.Object::ToString()
IL_000f: ldstr "sdffd"
IL_0014: call bool [mscorlib]System.String::op_Equality(string,
string)
IL_0019: or
IL_001a: ldc.i4.0
IL_001b: ceq
IL_001d: stloc.2
IL_001e: ldloc.2
IL_001f: brtrue.s IL_002e
IL_0021: nop
IL_0022: ldstr "dddd"
IL_0027: call void [mscorlib]System.Console::WriteLine(string)
IL_002c: nop
IL_002d: nop
IL_002e: ldloc.1
IL_002f: ldloc.1
IL_0030: or
IL_0031: call void [mscorlib]System.Console::WriteLine(int32)
IL_0036: nop
IL_0037: call int32 [mscorlib]System.Console::Read()
IL_003c: pop
IL_003d: ret
} // end of method Program::Main

cuando usas || para probar "a == null" y "a.ToString () ==" sdffd ", la IL será

 .method private hidebysig static void Main() cil managed
{
.entrypoint
// Code size 63 (0x3f)
.maxstack 2
.locals init ([0] object a,
[1] int32 b,
[2] bool CS$4$0000)
IL_0000: nop
IL_0001: ldnull
IL_0002: stloc.0
IL_0003: ldc.i4.3
IL_0004: stloc.1
IL_0005: ldloc.0
IL_0006: brfalse.s IL_001d
IL_0008: ldloc.0
IL_0009: callvirt instance string [mscorlib]System.Object::ToString()
IL_000e: ldstr "sdffd"
IL_0013: call bool [mscorlib]System.String::op_Equality(string,
string)
IL_0018: ldc.i4.0
IL_0019: ceq
IL_001b: br.s IL_001e
IL_001d: ldc.i4.0
IL_001e: stloc.2
IL_001f: ldloc.2
IL_0020: brtrue.s IL_002f
IL_0022: nop
IL_0023: ldstr "dddd"
IL_0028: call void [mscorlib]System.Console::WriteLine(string)
IL_002d: nop
IL_002e: nop
IL_002f: ldloc.1
IL_0030: ldloc.1
IL_0031: or
IL_0032: call void [mscorlib]System.Console::WriteLine(int32)
IL_0037: nop
IL_0038: call int32 [mscorlib]System.Console::Read()
IL_003d: pop
IL_003e: ret
} // end of method Program::Main

Ahora puedes ver la diferencia, por favor no pienses que ''|'' o ''y'' como operador condicional, es solo un operador lógico, no creo que sea necesario usarlo para juzgar las condiciones

Answer 4

OrElse está cortocircuitado , esto significa que solo se probará un lado de la expresión si el primer lado es una coincidencia.

Al igual que AndAlso solo probará un lado de la expresión si la primera mitad falla.

Answer 5

OrElse evalúa la primera expresión y luego si es verdadera, procederá a la declaración mientras OR evalúa dos expresiones antes de proceder a su declaración.

Ejemplo:

Textbox1.Text= 4
Textbox2.Text= ""

Usando OrElse

 If TextBox1.Text > 2 OrElse TextBox2.Text > 3 Then
MsgBox("True")
End If

El resultado es: VERDADERO

Usando OR

 If TextBox1.Text > 2 Or TextBox2.Text > 3 Then
MsgBox("True")
End If

El resultado es: Error no puede convertir cadena a doble.

Answer 6

OrElse es un operador de cortocircuito , Or no lo es.

Según la definición del operador booleano ''o'', si el primer término es verdadero, entonces el todo es definitivamente cierto, por lo que no es necesario evaluar el segundo término.

OrElse sabe, por lo que no prueba y evalúa temp = 0 una vez que se establece que la temp Is DBNull.Value

Or no lo sabe, y siempre intentará evaluar ambos términos. Cuando temp Is DBNull.Value , no se puede comparar con cero, por lo que se cae.

Deberías usar ... bueno, cualquiera que tenga sentido.