Difference between "or" and "and" (|, ||, &, &&)

In C#, there is not "or" and "and". The operators '||' and '&&' are 1) optimized variants of '|' and '&', 2) '||' and '&&' are only Boolean operators, but '|' and '&' are also bitwise ones.

Why use Boolean '|' and '&' then? They are really best avoided, but, for completeness of the Boolean arithmetic, they are needed. You will see the difference if you use a Boolean function with a side effect. Using such functions in a Boolean expression is highly discouraged, but what happens if you do it? Let's see:

bool result = Left() || Right();

As the operator '||' is optimized, it won't evaluate the redundant operand. If Left() returns true, the whole expression will always be true, so the expression evaluation won't call Right(). If Right() has some side effect, it would be lost (never happen).

Likewise in

bool result = Left() && Right();

if Left() returns false, the whole expression is always false, so the expression evaluation won't call Right(). If Right() has some side effect, it would be lost.

Expressions with '|' or '&' will always evaluate all the operands; this way, both functions will always be called. Same thing goes about properties with the getters which cause any side effect.

I hope everything is clear now.

—SA

[EDIT]Fixed apparent copy-paste errors - Matt Heffron[/EDIT]

If string is not "" then it must be something else.
If string is not null then it must be something else.

So you are saying

If string is something other than "" OR it is something other than null...

Well, if it is "" it is something other than null and if it is null it is something other than "".

When it is confusing, look at it and replace each part of the if using an example. So, say the string is null.

If string != "" || string != null
becomes

if true || false

which = true.

Using && you are saying

IF the string is something other than "" AND it is also something other than null ... in other words, if it is neither null nor empty.


(In fact there is a method String.IsNullOrEmpty() you can use which helps!)


P.S. You should check for null first, as the || and && operators do the checking left to right, so you may get a null reference exception when what you are checking is null.

Beside other issues as mentioned in other solutions (e.g. use string.IsNullOrEmpty(str) or if you insist on using your code, first check for null and only then for a defined value, etc.), I think you are confusing with the basic logic: the De Morgan's Law (e.g. see http://en.wikipedia.org/wiki/De_Morgan's_laws[^]).

It defines the logic of negation (pseudo code):

not(a) and not(b) = not(a or  b)
not(a) or  not(b) = not(a and b)

What you have in the first code evolves as shown bellow according to De Morgan's law (I take the check for null first):

  (str != null) ||  (str != "")
 !(str == null) || !(str == "")
!((str == null) &&  (str == ""))
!             false // not both can be true at the same time
              true

This shows clearly that the result is always true.

The second code evolves as follows (null check first again):

  (str != null) &&  (str != "")
 !(str == null) && !(str == "")
!((str == null) ||  (str == ""))

This is one of

a)     !  (true || false)    --> str equals null
       !       true
               false         
b)     ! (false || true)     --> str equals ""
       !       true
               false
c)     ! (false || false)    --> str is neither null nor empty
       !       false
               true

So, the second line gives identical result to:

if (!string.IsNullOrEmpty(str)) { ... }

Cheers
Andi

MSDN help:

The predefined Boolean logical operators are:

C#

bool operator &(bool x, bool y);
bool operator |(bool x, bool y);
bool operator ^(bool x, bool y);

The result of x & y is true if both x and y are true. Otherwise, the result is false.

The result of x | y is true if either x or y is true. Otherwise, the result is false.

The result of x ^ y is true if x is true and y is false, or x is false and y is true. Otherwise, the result is false. When the operands are of type bool, the ^ operator computes the same result as the != operator.

Source: Boolean logical operators[^]

More at: http://msdn.microsoft.com/en-us/library/6a71f45d.aspx[^]