Using Boolean Operators

Using Boolean Operators

A Boolean operator is an operator whose result is either true or false. C# has several very useful Boolean operators, the simplest of which is the NOT operator, which is represented by the exclamation point symbol (!). The ! operator negates a Boolean value, yielding the opposite of that value. In the previous example, if the value of the variable areYouReady is true, the value of the expression !areYouReady is false.

Understanding Equality and Relational Operators

Two much more commonly used Boolean operators are the equality (==) and inequality (!=) operators. You use these binary operators to find out whether a value is the same as another value of the same type. The following table summarizes how these operators work, using an int variable called age as an example.

Operator	Meaning	Example	Outcome if age is 42
--	Equal to	age -- 100	false
!=	Not equal to	age != 0	true

Closely related to these two operators are the relational operators. You use these operators to find out whether a value is less than or greater than another value of the same type. The following table shows how to use these operators.

Operator	Meaning	Example	Outcome if age is 42
<	Less than	age < 21	false
<=	Less than or equal to	age <= 18	false
>	Greater than	age > 16	true
>=	Greater than or equal to	age >= 30	true

NOTE
Don't confuse the equality operator == with the assignment operator =. Code such as x==y compares x to y and has the value true if the values are the same. Code such as x=y assigns the value of y to x.

Understanding Conditional Logical Operators

C# also provides two other Boolean operators: the logical AND operator, which is represented by the && symbol, and the logical OR operator, which is represented by the || symbol. Collectively, these are known as the conditional logical operators. Their purpose is to combine Boolean expressions together into bigger expressions. These binary operators are similar to the equality and relational operators in that their outcome is either true or false, but they differ in that the values they operate on must themselves be either true or false.

The outcome of the && operator is true if and only if both of the Boolean expressions it operates on are true. For example, the following statement assigns the value true to validPercentage if and only if the value of percent is greater than or equal to zero and the value of percent is less than or equal to 100:

bool validPercentage;  validPercentage = (percent >= 0) && (percent <= 100);

TIP
A common beginner's error is to try to combine the two tests by naming the percent variable only once, like this:

percent >= 0 && <= 100 // this statement will not compile.

Using parentheses helps avoid this type of mistake and also clarifies the purpose of the expression. For example, compare these two expressions:

validPercentage = percent >= 0 && percent <= 100  validPercentage = (percent >= 0) && (percent <= 100)

Both expressions return the same value, because the precedence of the && operator is less than that of >= and <=. However, the second expression conveys its purpose in a more readable manner.

The outcome of the || operator is true if either of the Boolean expressions it operates on is true. You use the || operator to determine whether any one of a combination of Boolean expressions is true. For example, the following statement assigns the value true to invalidPercentage if the value of percent is less than zero, or the value of percent is greater than 100:

bool invalidPercentage;  invalidPercentage = (percent < 0) || (percent > 100);

Short Circuiting

The && and || operators both exhibit a feature called short circuiting. Sometimes it is not necessary to evaluate both operands. For example, if the left operand of the && operator evaluates to false, then the result of the entire expression is false regardless of the value of the right operand. Similarly, if the value of the left operand of the || operator evaluates to true, the result of the entire expression is true. In these cases, the && and || operators bypass the evaluation of the right Boolean expressions. Here are some examples:

(percent >= 0) && (percent <= 100)

In this expression, if the value of percent is less than zero, the Boolean expression on the left side of && evaluates to false. This value means that the result of the entire expression must be false, regardless of the remaining expression; therefore, the Boolean expression on the right side of && is not evaluated.

(percent < 0) || (percent > 100)

In this expression, if the value of percent is less than zero, the Boolean expression on the left side of || evaluates to true. This value means that the result of the entire expression must be true; therefore, the Boolean expression on the right side of || is not evaluated.

If you carefully design expressions that use the conditional logical operators, you can boost the performance of your code by avoiding unnecessary work. Place simple Boolean expressions that can be evaluated easily on the left side of a conditional logical operator and put more complex expressions on the right side. In many cases, you will find that the program does not need to evaluate the more complex expressions.

Summarizing Operator Precedence and Associativity

The following table summarizes the precedence and associativity of all the operators you have learned about so far. Operators in the same category have the same precedence. Operators in a higher category take precedence over operators in a lower category.

Category	Operators	Description	Associativity
Primary	( ) ++ --	Precedence override Post-increment Post-decrement	Left
Unary	! + - ++ --	Logical NOT Addition Subtraction Pre-increment Pre-decrement	Left
Multiplicative	* / %	Multiply Divide Division remainder	Left
Additive	+ -	Addition Subtraction	Left
Relational	< <= > >=	Less than Less than or equal Greater than Greater than or equal	Left
Equality	== !=	Equal to Not equal to	Left
Conditional AND	&&	Logical AND	Left
Conditional OR	||	Logical OR	Left
Assignment	=		Right