Or versus OrElse

前端 未结 8 1570
感情败类
感情败类 2020-11-27 04:33

What\'s the difference between or and OrElse?

if temp is dbnull.value or temp = 0

produces the error:

相关标签:
8条回答
  • 2020-11-27 04:43

    Unless your code logic requires the short-circuiting behavior OrElse provides, I would lean toward using the Or operator because:

    • Using "Or" is simple and requires less typing.
    • The computational time savings of using OrElse is negligible in most cases.
    • Most importantly, using OrElse can hide errors in later clauses that may not be initially revealed until those conditions would eventually be met by the program logic.
    0 讨论(0)
  • 2020-11-27 04:47

    The Bert' s answer is not very accurate. The '|' or '&' is logical operator, in C #, it always treat as bit operator, please see the following code as example

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

    The following is 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      "ffffdd"
       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
    

    when you use || to test "a == null" and "a.ToString() == "sdffd", the IL will be

     .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      "ffffdd"
      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
    

    Now you can see the difference, please don't think the '|' or 'and' as conditional operator, it just a logical operator, I don't think there is necessary to use it to judge condition

    0 讨论(0)
  • 2020-11-27 04:48

    OrElse is a short-circuiting operator, Or is not.

    By the definition of the boolean 'or' operator, if the first term is True then the whole is definitely true - so we don't need to evaluate the second term.

    OrElse knows this, so doesn't try and evaluate temp = 0 once it's established that temp Is DBNull.Value

    Or doesn't know this, and will always attempt to evaluate both terms. When temp Is DBNull.Value, it can't be compared to zero, so it falls over.

    You should use... well, whichever one makes sense.

    0 讨论(0)
  • 2020-11-27 04:54

    (I've looked at other answers and realized I was terribly wrong)

    The OrElse operator "performs short-circuiting logical disjunction on two expressions", that is to say: if the left operand is true and so the entire expression is guaranteed to be true the right operand won't even be evaluated (this is useful in cases like:

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

    to avoid a NullReferenceException throw by the right-hand operand.

    I'm sincerely astonished that this (lazy evaluation) isn't the default behaviour of or and and as it is in C/C++ and C# (and many other languages...)

    0 讨论(0)
  • 2020-11-27 04:55

    OrElse evaluate first expression then if its true it will proceed to the statement while OR evaluates two expressions before it will proceed to their statement.

    Example:

    Textbox1.Text= 4
    
    Textbox2.Text= ""
    

    Using OrElse

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

    Result is: TRUE


    Using OR

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

    Result is: Error cannot convert string to double.

    0 讨论(0)
  • 2020-11-27 04:58

    This is the same behaviour as with C#, where everyone uses the Coditional Or (||) and the Conditional And (&&), where you also have the normal Or (|) and normal And (&). So comparing C# to VB.Net is:

    | => Or

    || => OrElse

    & => And

    && => AndAlso

    The condifitonal boolean operators are very usefull preventing nested if constructions. But sometimes the normal boolean operators are needed to ensure hitting both code paths.

    0 讨论(0)
提交回复
热议问题