> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C# Conditional Logical AND
The `&&` operator in C# is the conditional logical AND operator. It evaluates two expressions and returns `true` if both operands evaluate to `true`; otherwise, it returns `false`. Its defining technical characteristic is short-circuit evaluation.
```csharp theme={"dark"}
bool leftOperand = true;
bool rightOperand = false;
bool result = leftOperand && rightOperand; // Evaluates to false
```
## Evaluation Mechanics and Short-Circuiting
The `&&` operator enforces strict left-to-right evaluation with short-circuiting behavior. The execution flow is as follows:
1. The left operand is evaluated.
2. If the left operand evaluates to `false`, the overall expression cannot possibly be `true`. The operator immediately returns `false`, and the right operand is **not evaluated**.
3. If the left operand evaluates to `true`, the right operand is evaluated, and its result becomes the result of the entire expression.
This behavior contrasts with the boolean logical AND operator (`&`), which always evaluates both operands regardless of the left operand's result when applied to `bool` types.
```csharp theme={"dark"}
bool EvaluateLeft()
{
System.Console.WriteLine("Left evaluated.");
return false;
}
bool EvaluateRight()
{
System.Console.WriteLine("Right evaluated.");
return true;
}
// The following line will only print "Left evaluated."
// EvaluateRight() is bypassed due to short-circuiting.
bool result = EvaluateLeft() && EvaluateRight();
```
## Type Constraints and Overloading
* **Standard Types:** For standard boolean logic, both operands must be of type `bool`.
* **Nullable Booleans:** The `&&` operator does not directly support `bool?` (nullable boolean) operands. To evaluate nullable booleans, you must explicitly cast them, access the `.Value` property, or use the boolean logical AND operator (`&`), which supports three-valued logic.
* **User-Defined Types:** The `&&` operator itself cannot be explicitly overloaded. However, user-defined types can support `&&` evaluation by overloading the `true`, `false`, and `&` operators. When evaluated this way:
* The custom type does **not** need to be implicitly convertible to `bool`.
* The short-circuiting logic relies on the overloaded `false` operator applied to the left operand.
* The overall `&&` expression evaluates to the return type of the overloaded `&` operator (typically the custom type itself), rather than strictly returning a `bool`.
## Precedence and Associativity
* **Associativity:** The `&&` operator is left-associative. An expression like `a && b && c` is parsed and evaluated as `(a && b) && c`.
* **Precedence:** It holds a lower precedence than equality operators (`==`, `!=`) and the boolean/bitwise logical operators (`&`, `^`, `|`), but a higher precedence than the conditional logical OR operator (`||`).
```csharp theme={"dark"}
int a = 1;
int b = 1;
bool c = false;
bool d = true;
// Due to precedence, this is evaluated as:
// bool precedenceResult = ((a == b) && c) || d;
bool precedenceResult = a == b && c || d; // Evaluates to true
```
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
