Operadores lógicos en C# (Cómo funciona para desarrolladores)

Logical AND Operator (&&)

The logical AND operator (&&) combines two boolean expressions and returns true if both are true. If either or both are false, the result is false. Commonly used in multi-condition scenarios where all conditions must be met. For example, validating if a user is old enough and has enough balance to purchase.

The && operator:

• Evaluates the left operand
• If the left operand is false, the entire expression is false
• If the left operand is true, the right operand is evaluated
• The expression is true if both operands are true

If the left operand is false, the right operand is not evaluated, as the entire expression is guaranteed to be false.

class Program
{
    static void Main(string[] args)
    {
        bool isAdult = true;
        bool hasBalance = false;
        bool canPurchase = isAdult && hasBalance;

        // Output the result to the console; expected output is false
        Console.WriteLine(canPurchase); // Output: false
    }
}

class Program
{
    static void Main(string[] args)
    {
        bool isAdult = true;
        bool hasBalance = false;
        bool canPurchase = isAdult && hasBalance;

        // Output the result to the console; expected output is false
        Console.WriteLine(canPurchase); // Output: false
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim isAdult As Boolean = True
		Dim hasBalance As Boolean = False
		Dim canPurchase As Boolean = isAdult AndAlso hasBalance

		' Output the result to the console; expected output is false
		Console.WriteLine(canPurchase) ' Output: false
	End Sub
End Class

In this example, even though isAdult is true, hasBalance is false, so the result is false.

Logical OR Operator (

The logical OR operator (||) combines two boolean expressions and returns true if at least one is true. If both are false, the result is false. Ideal for scenarios where at least one of several conditions must be true. For example, allowing entry if a person is a member or has a ticket.

The || operator:

• Evaluates the left operand
• If the left operand is true, the entire expression is true
• If the left operand is false, the right operand is evaluated
• The expression is true if either operand is true

If the left operand is true, the right operand is not evaluated, as the entire expression is guaranteed to be true.

class Program
{
    static void Main(string[] args)
    {
        bool isMember = true;
        bool hasTicket = false;
        bool canEnter = isMember || hasTicket;

        // Output the result to the console; expected output is true
        Console.WriteLine(canEnter); // Output: true
    }
}

class Program
{
    static void Main(string[] args)
    {
        bool isMember = true;
        bool hasTicket = false;
        bool canEnter = isMember || hasTicket;

        // Output the result to the console; expected output is true
        Console.WriteLine(canEnter); // Output: true
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim isMember As Boolean = True
		Dim hasTicket As Boolean = False
		Dim canEnter As Boolean = isMember OrElse hasTicket

		' Output the result to the console; expected output is true
		Console.WriteLine(canEnter) ' Output: true
	End Sub
End Class

Here, since isMember is true, hasTicket is not even evaluated, and the result is true.

Logical NOT Operator (!)

class Program
{
    static void Main(string[] args)
    {
        bool isLoggedOn = false;
        bool showLoginButton = !isLoggedOn;

        // Output the result to the console; expected output is true
        Console.WriteLine(showLoginButton); // Output: true
    }
}

class Program
{
    static void Main(string[] args)
    {
        bool isLoggedOn = false;
        bool showLoginButton = !isLoggedOn;

        // Output the result to the console; expected output is true
        Console.WriteLine(showLoginButton); // Output: true
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim isLoggedOn As Boolean = False
		Dim showLoginButton As Boolean = Not isLoggedOn

		' Output the result to the console; expected output is true
		Console.WriteLine(showLoginButton) ' Output: true
	End Sub
End Class

bool isWeekend = false;
bool hasVacation = true;
bool isWorkDay = !(isWeekend || hasVacation);

// Output the result to the console; expected output is false
Console.WriteLine(isWorkDay); // Output: false

bool isWeekend = false;
bool hasVacation = true;
bool isWorkDay = !(isWeekend || hasVacation);

// Output the result to the console; expected output is false
Console.WriteLine(isWorkDay); // Output: false

Dim isWeekend As Boolean = False
Dim hasVacation As Boolean = True
Dim isWorkDay As Boolean = Not (isWeekend OrElse hasVacation)

' Output the result to the console; expected output is false
Console.WriteLine(isWorkDay) ' Output: false

Logical XOR Operator (^)

The logical XOR operator (^) returns true if the two operands have different values. If both are the same, it returns false. This operator is particularly useful when you want to ensure that exactly one of two conditions is true, but not both.

class Program
{
    static void Main(string[] args)
    {
        bool hasPassword = true;
        bool hasSmartCard = false;
        bool canLogin = hasPassword ^ hasSmartCard;

        // Output the result to the console; expected output is true
        Console.WriteLine(canLogin); // Output: true
    }
}

class Program
{
    static void Main(string[] args)
    {
        bool hasPassword = true;
        bool hasSmartCard = false;
        bool canLogin = hasPassword ^ hasSmartCard;

        // Output the result to the console; expected output is true
        Console.WriteLine(canLogin); // Output: true
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim hasPassword As Boolean = True
		Dim hasSmartCard As Boolean = False
		Dim canLogin As Boolean = hasPassword Xor hasSmartCard

		' Output the result to the console; expected output is true
		Console.WriteLine(canLogin) ' Output: true
	End Sub
End Class

Since the values of hasPassword and hasSmartCard are different, the logical XOR returns true. If both were true or both were false, it would return false.

Compound Assignment Operator

A compound assignment operator combines arithmetic with the assignment. They are shorthand for performing an operation and assigning the result to the variable. Here are some types of compound assignment operators:

• +=: Add and assign
• -=: Subtract and assign
• *=: Multiply and assign
• /=: Divide and assign
• %=: Modulus and assign
• &=: Bitwise AND and assign
• |=: Bitwise OR and assign
• ^=: Bitwise XOR and assign

And here they are in action:

int x = 5;
x += 3; // Equivalent to x = x + 3; x is now 8

int x = 5;
x += 3; // Equivalent to x = x + 3; x is now 8

Dim x As Integer = 5
x += 3 ' Equivalent to x = x + 3; x is now 8

Arithmetic Operators

Arithmetic operators perform standard mathematical operations. They include:

• +: Addition
• -: Subtraction
• *: Multiplication
• /: Division
• %: Modulus (remainder of division)

Operator Precedence

Operator precedence defines the order in which operations are performed in an expression. For example, multiplication and division are performed before addition and subtraction.

Here is the order of operator precedence in C#:

1. Logical NOT (!)
2. Multiplicative (*, /, %)
3. Additive (+, -)
4. Relational and type testing (<, >, <=, >=, is, as)
5. Equality (==, !=)
6. Logical AND (&&)
7. Logical OR (||)

Bitwise Operators

Apart from logical operators that work on boolean values, some bitwise logical operators work on the binary representation of integers. The types of bitwise logical operators are:

• &: Bitwise AND
• |: Bitwise OR
• ^: Bitwise XOR
• ~: Bitwise NOT
• <<: Left Shift
• >>: Right Shift

These bitwise operators enable you to manipulate individual bits within an integer value.

IronPDF

IronPDF enables developers to create, read, edit, and convert PDF documents within a C# application. Consider a scenario where you must filter and extract specific information from a PDF based on certain conditions. Logical operators can be employed to define these conditions, enabling the program to make intelligent decisions on what data to extract or manipulate.

Discover how IronPDF enhances PDF document handling.

IronXL

IronXL simplifies working with Microsoft Excel files, allowing you to read, write, and manipulate spreadsheets directly in C#. You can utilize logical operators to create dynamic conditions while processing data. For example, using the logical AND operator to filter records that meet multiple criteria or using the logical OR operator to select rows that meet several conditions.

Learn about working with Excel using IronXL.

IronOCR

IronOCR is a potent tool that empowers your C# application to recognize and read text from images. Logical operators can play a part in post-processing the extracted text. Imagine a use case where you need to validate the extracted information. Using logical NOT, AND, OR operators, you can create complex validation rules to ensure the data's accuracy.

See how IronOCR enables optical character recognition.

IronBarcode

IronBarcode adds the ability to generate, read, and recognize barcodes within a C# application. You may use logical operators to determine what type of barcode to develop or read based on specific conditions or to validate barcode data according to certain logical rules.

Find out how IronBarcode manages barcode operations.