Ou contre OrElse

Quelle est la différence entre or et OrElse ?

if temp is dbnull.value or temp = 0

produit l'erreur:

L'opérateur '=' n'est pas défini pour le type 'DBNull' et le type 'Integer'.

alors que celui-ci fonctionne comme un charme !?

if temp is dbnull.value OrElse temp = 0

OrElseest un opérateur de court-circuit , Orne l'est pas.

Par la définition de l'opérateur booléen 'ou', si le premier terme est Vrai, alors le tout est définitivement vrai - nous n'avons donc pas besoin d'évaluer le deuxième terme.

OrElsele sait, donc n'essaye pas d'évaluer temp = 0une fois qu'il est établi quetemp Is DBNull.Value

Orne le sait pas et tentera toujours d'évaluer les deux termes. Quand temp Is DBNull.Value, il ne peut pas être comparé à zéro, alors il tombe.

Vous devriez utiliser ... eh bien, celui qui a du sens.

C'est le même comportement qu'avec C #, où tout le monde utilise le Coditional Or (||) et le Conditional And (&&), où vous avez également le Or normal (|) et le And normal (&). Donc, comparer C # à VB.Net est:

| => Ou

|| => OuElse

& => Et

&& => EtAussi

Les opérateurs booléens conditionnels sont très utiles pour empêcher les constructions if imbriquées. Mais parfois, les opérateurs booléens normaux sont nécessaires pour s'assurer d'atteindre les deux chemins de code.

OrElse est court-circuité , cela signifie qu'un seul côté de l'expression sera testé si le premier côté correspond.

Tout comme AndAlso ne testera qu'un côté de l'expression si la première moitié est un échec.

(J'ai regardé d'autres réponses et réalisé que j'avais terriblement tort)

L'opérateur OrElse "effectue une disjonction logique de court-circuit sur deux expressions", c'est-à-dire: si l'opérande gauche est vrai et que l'expression entière est donc garantie vraie, l'opérande droit ne sera même pas évalué (cela est utile dans des cas comme:

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

pour éviter une NullReferenceException lancée par l'opérande de droite.

Je suis sincèrement étonné que cette ( évaluation paresseuse ) ne soit pas le comportement par défaut de oret andcomme c'est le cas en C / C ++ et C # (et dans de nombreux autres langages ...)

OuElse évalue la première expression, puis si c'est vrai, il passera à l'instruction tandis que OU évalue deux expressions avant de passer à leur instruction.

Exemple:

Textbox1.Text= 4

Textbox2.Text= ""

Utiliser OrElse

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

Le résultat est: TRUE

Utiliser OR

 If TextBox1.Text > 2 Or TextBox2.Text > 3 Then

            MsgBox("True")
  End If

Le résultat est: L' erreur ne peut pas convertir la chaîne en double.

La réponse de Bert n'est pas très précise. Le '|' ou '&' est un opérateur logique, en C #, il est toujours traité comme un opérateur de bit, veuillez consulter le code suivant comme exemple

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

Ce qui suit est 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

lorsque vous utilisez || pour tester "a == null" et "a.ToString () ==" sdffd ", l'IL sera

 .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

Maintenant, vous pouvez voir la différence, ne pensez pas que le «|» ou 'et' comme opérateur conditionnel, c'est juste un opérateur logique, je ne pense pas qu'il soit nécessaire de l'utiliser pour juger la condition

À moins que votre logique de code ne nécessite le comportement de court-circuit fourni par OrElse, je pencherais vers l'utilisation de l'opérateur Or car:

• L'utilisation de "Ou" est simple et nécessite moins de frappe.
• Le gain de temps de calcul lié à l'utilisation d'OrElse est négligeable dans la plupart des cas.
• Plus important encore, l'utilisation d'OrElse peut masquer des erreurs dans des clauses ultérieures qui peuvent ne pas être initialement révélées jusqu'à ce que ces conditions soient finalement remplies par la logique du programme.

La raison pour laquelle la compilation échoue dans l'exemple est l'ordre des opérations.

L'analyseur d'expression essaie d'abord d'évaluer "dbnull.value ou temp".

if temp is (dbnull.value or temp) = 0

L'erreur est là, car vous ne pouvez pas faire un OU au niveau du bit entre un entier (temp) et dbnull.value.

OrElse corrige ce problème, non pas parce qu'il est court-circuité, mais parce qu'il est plus bas dans l'ordre des opérations , et donc "temp is dbnull.value" et "3 = 0" sont évalués en premier, plutôt que l'analyseur essayant de comparer dbNull et temp.

Ainsi, l'évaluation avec OrElse fonctionne comme prévu: (supposons que temp = 3)

if temp is dbnull.value OrElse temp = 0 then
if 3 is dbnull.value OrElse 3 = 0 then
if false OrElse 3=0 then
if false OrElse false then
if false then

C'était en fait lors d'un examen d'entrée dans une société de logiciels pour laquelle je travaillais, et c'était un problème courant que j'avais l'habitude de rencontrer dans VB6. C'est donc une bonne idée de mettre entre parenthèses vos sous-expressions lorsque vous utilisez des opérateurs booléens:

Cela aurait compilé correctement:

if (temp is dbnull.value) Or (temp = 0) then 

Bien que, comme tout le monde l'a déjà souligné, OrElse et AndAlso sont vraiment les bons opérateurs à utiliser dans ce contexte.