O contro OrElse

Qual è la differenza tra or e OrElse ?

if temp is dbnull.value or temp = 0 

produce l’errore:

L’operatore ‘=’ non è definito per il tipo ‘DBNull’ e digitare ‘Intero’.

mentre questo funziona come un fascino !?

 if temp is dbnull.value OrElse temp = 0 

OrElse è un operatore in cortocircuito , Or no.

Con la definizione dell’operatore booleano ‘o’, se il primo termine è Vero, allora il tutto è assolutamente vero – quindi non abbiamo bisogno di valutare il secondo termine.

OrElse sa, quindi non prova a valutare temp = 0 una volta stabilito che temp Is DBNull.Value

Or non lo sa, e tenterà sempre di valutare entrambi i termini. Quando temp Is DBNull.Value , non può essere paragonato a zero, quindi cade.

Dovresti usare … beh, qualunque abbia senso.

Questo è lo stesso comportamento di C #, dove tutti usano il Codificante O (||) e il Condizionale E (&&), dove hai anche il normale Or (|) e normale And (&). Quindi confrontare C # con VB.Net è:

| => Or

|| => OrElse

& => E

&& => AndAlso

Gli operatori booleani condizionati sono molto utili nel prevenire costruzioni annidate. Ma a volte sono necessari i normali operatori booleani per assicurare di colpire entrambi i percorsi del codice.

OrElse è cortocircuitato , questo significa che solo un lato dell’espressione sarà testato se il primo lato è una corrispondenza.

Proprio come AndAlso testerà solo una parte dell’espressione se il primo semestre è un fallimento.

(Ho visto altre risposte e ho capito che ero terribilmente sbagliato)

L’operatore OrElse “esegue la disgiunzione logica di cortocircuito su due espressioni”, vale a dire: se l’operando di sinistra è vero e quindi l’intera espressione è garantita come vera, l’operando di destra non verrà nemmeno valutato (questo è utile in casi come:

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

per evitare un lancio di NullReferenceException da parte dell’operando di destra.

Sono sinceramente sbalordito dal fatto che questa ( valutazione lazy ) non sia il comportamento predefinito di or and come in C / C ++ e C # (e in molti altri linguaggi …)

La risposta di Bert non è molto accurata. Il ‘|’ o “&” è operatore logico, in C #, considera sempre come operatore bit, vedere il seguente codice come esempio

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

Quello che segue è 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 

quando usi || per testare “a == null” e “a.ToString () ==” sdffd “, l’IL sarà

  .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 

Ora puoi vedere la differenza, per favore non pensare che il ‘|’ o “e” come operatore condizionale, è solo un operatore logico, non penso che sia necessario utilizzarlo per giudicare le condizioni

OrElse valuta la prima espressione, quindi se è vera procede alla dichiarazione mentre OR valuta due espressioni prima di procedere alla loro dichiarazione.

Esempio:

 Textbox1.Text= 4 Textbox2.Text= "" 

Utilizzando OrElse

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

Il risultato è: TRUE


Utilizzando OR

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

Il risultato è: l’ errore non può convertire la stringa in doppia.