Logical operators in C#

Logical operators are special symbols that allow us to combine conditions and perform operations based on the result of those conditions. The most common logical operators in C# are:

List of logical operators

Logical AND (&&)

The logical AND operator allows us to evaluate two conditions and returns true if both conditions are true, or false otherwise. For example:

bool condition1 = true;
bool condition2 = false;
bool result = condition1 && condition2; // result will be false

Logical OR (||)

The logical OR operator allows us to evaluate two conditions and returns true if at least one of the conditions is true, or false otherwise. For example:

bool condition1 = true;
bool condition2 = false;
bool result = condition1 || condition2; // result will be true

Logical NOT (!)

The logical NOT operator allows us to invert the value of a condition. If the condition is true, it returns false, and if the condition is false, it returns true. For example:

bool condition = true;
bool result = !condition; // result will be false

Usage Examples

Combination with &&

The && operator (logical AND) is used to combine two boolean expressions. The entire expression evaluates to true only if both sub-expressions are true.

int age = 25;
bool hasLicense = true;

bool canDrive = (age >= 18) && hasLicense; // true

Combination with ||

The || operator (logical OR) is used to combine two boolean expressions. The entire expression evaluates to true if at least one of the sub-expressions is true.

bool isRaining = false;
bool isCold = true;

bool wantsToStayHome = isRaining || isCold; // true

Negation with !

The ! operator (logical NOT) is used to negate a boolean expression. The entire expression evaluates to true if the sub-expression is false, and vice versa.

bool isDay = true;
bool isNight = !isDay; // false

Combination of Logical Operators

It is possible to combine multiple logical operators in a single expression to create more complex conditions. For example:

int number = 15;

bool isMultipleOf3 = (number % 3 == 0);
bool isMultipleOf5 = (number % 5 == 0);

bool isMultipleOf3_or_5 = isMultipleOf3 || isMultipleOf5; // true, since 15 is a multiple of 3
bool isMultipleOf3_and_5 = isMultipleOf3 && isMultipleOf5; // false, since 15 is not a multiple of 3 and 5 simultaneously
bool isNotMultipleOf3 = !isMultipleOf3; // false

Precedence of Logical Operators

When combining multiple logical operators in an expression, it is important to understand their precedence to correctly evaluate the expression.

Therefore, in an expression with && and ||, && is evaluated before ||. However, it is advisable not to overuse this when writing our code. Don’t hesitate to use parentheses if it improves readability.

For example:

int a = 5;
int b = 10;
int c = 15;

bool result = (a > b) || (b < c) && (a == c); // true
// Evaluated as: (a > b) || ((b < c) && (a == c))

bool result = (a > b) || ((b < c) && (a == c)); // true