Suppose that we wish to ensure at some point in an app that two conditions are both true before we choose a certain path of execution. In this case, we can use the && (conditional AND) operator, as follows:

if (gender == 'F' && age >= 65)
{
   ++seniorFemales;
}

This if statement contains two simple conditions. The condition gender == 'F' determines whether a person is female. The condition age >= 65 might be evaluated to determine whether a person is a senior citizen. The if statement considers the combined condition

gender == 'F' && age >= 65

which is true if and only if both simple conditions are true. If the combined condition is true, the if statement’s body increments seniorFemales by 1. If either or both of the simple conditions are false, the app skips the increment. Some programmers find that the preceding combined condition is more readable when redundant parentheses are added, as in

(gender == 'F') && (age >= 65)

The table in Fig. 6.15 summarizes the && operator. The table shows all four possible combinations of false and true values for expression1 and expression2. Such tables are called truth tables. C# evaluates all expressions that include relational operators, equality operators or logical operators to bool values—which are either true or false.

Now suppose we wish to ensure that either or both of two conditions are true before we choose a certain path of execution. In this case, we use the || (conditional OR) operator, as in the following app segment:

if ((semesterAverage >= 90) || (finalExam >= 90))
{
   Console.WriteLine ("Student grade is A");
}

This statement also contains two simple conditions. The condition semesterAverage >= 90 is evaluated to determine whether the student deserves an A in the course because of a solid performance throughout the semester. The condition finalExam >= 90 is evaluated to determine whether the student deserves an A in the course because of an outstanding performance on the final exam. The if statement then considers the combined condition

(semesterAverage >= 90) || (finalExam >= 90)

and awards the student an A if either or both of the simple conditions are true. The only time the message "Student grade is A" is not displayed is when both of the simple conditions are false. Figure 6.16 is a truth table for operator conditional OR (||). Operator && has a higher precedence than operator ||. Both operators associate from left to right.

The parts of an expression containing && or || operators are evaluated only until it’s known whether the condition is true or false. Thus, evaluation of the expression

(gender == 'F') && (age >= 65)

stops immediately if gender is not equal to 'F' (i.e., at that point, it’s certain that the entire expression is false) and continues only if gender is equal to 'F' (i.e., the entire expression could still be true if the condition age >= 65 is true). This feature of conditional AND and conditional OR expressions is called short-circuit evaluation.

The boolean logical AND (&) and boolean logical inclusive OR (|) operators work identically to the && (conditional AND) and || (conditional OR) operators, with one exception—the boolean logical operators always evaluate both of their operands (i.e., they do not perform short-circuit evaluation). Therefore, the expression

(gender == 'F') & (age >= 65)

evaluates age >= 65 regardless of whether gender is equal to 'F'. This is useful if the right operand of the & or | operator has a required side effect—such as a modification of a variable’s value. For example, the expression

(birthday == true) | (++age >= 65)

guarantees that the condition ++age >= 65 will be evaluated. Thus, the variable age is incremented in the preceding expression, regardless of whether the overall expression is true or false.

A complex condition containing the boolean logical exclusive OR (^) operator (also called the logical XOR operator) is true if and only if one of its operands is true and the other is false. If both operands are true or both are false, the entire condition is false. Figure 6.17 is a truth table for the boolean logical exclusive OR operator. This operator is also guaranteed to evaluate both of its operands.

The ! (logical negation or not) operator enables you to “reverse” the meaning of a condition. Unlike the logical operators &&, ||, &, | and ^, which are binary operators that combine two conditions, the logical negation operator is a unary operator that has only a single condition as an operand. The logical negation operator is placed before a condition to choose a path of execution if the original condition (without the logical negation operator) is false, as in the code segment

if (! (grade == sentinelValue))
{
   Console.WriteLine($"The next grade is {grade}");
}

which executes the WriteLine call only if grade is not equal to sentinelValue. The parentheses around the condition grade == sentinelValue are needed because the logical negation operator has a higher precedence than the equality operator.

In most cases, you can avoid using logical negation by expressing the condition differently with an appropriate relational or equality operator. For example, the previous statement may also be written as

if (grade != sentinelValue)
{
   Console.WriteLine($"The next grade is {grade}");
}

This flexibility can help you express a condition in a more convenient manner. Figure 6.18 is a truth table for the logical negation operator.

Figure 6.19 demonstrates the logical operators and boolean logical operators by producing their truth tables. The output shows the expression that was evaluated and the bool result of that expression. Lines 10–14 produce the truth table for && (conditional AND). Lines 17–21 produce the truth table for || (conditional OR). Lines 24–28 produce the truth table for & (boolean logical AND). Lines 31–35 produce the truth table for | (boolean logical inclusive OR). Lines 38–42 produce the truth table for ^ (boolean logical exclusive OR). Lines 45–47 produce the truth table for ! (logical negation).