1. IronPDF
  2. IronPDF Blog
  3. .NET Help
  4. C# Logical Operators

Published August 30, 2023

C# Logical Operators (How it Works for Developers)

Understanding logical operators is essential when working with conditional statements in programming. In C#, the logical operators play a vital role in determining the truth value of given conditions. This guide will walk you through the fundamentals of logical operators in C#, including concepts like boolean values, operator precedence, logical negation, and much more.

Introduction to Logical Operators

Logical operators, commonly known as logical operations, form the core of decision-making in programming. They operate on boolean expressions, evaluating them to produce a boolean value of either true or false, depending on the conditions provided. These operators play a crucial role in controlling the flow of your program, allowing you to execute specific blocks of code based on certain criteria.

In this article, we'll dive into the different logical operators in C#, understanding their functions and showcasing how you can incorporate the logical operator into your applications to perform logical operations with precision and efficiency.

Types of Logical Operators in C#

1. 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.

AND

  • 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;
        Console.WriteLine(canPurchase); // Output: false
    }
}
class Program
{
    static void Main(string[] args)
    {
        bool isAdult = true;
        bool hasBalance = false;
        bool canPurchase = isAdult && hasBalance;
        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
		Console.WriteLine(canPurchase) ' Output: false
	End Sub
End Class
VB   C#

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

2. Logical OR Operator (OR)

The logical OR operator (OR) 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 OR 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;
        Console.WriteLine(canEnter); // Output: true
    }
}
class Program
{
    static void Main(string[] args)
    {
        bool isMember = true;
        bool hasTicket = false;
        bool canEnter = isMember 
                        hasTicket;
        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 hasTicket
		Console.WriteLine(canEnter) ' Output: true
	End Sub
End Class
VB   C#

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

3. Logical NOT Operator (!)

The logical NOT operator (!) inverts the value of a boolean expression. If the operand is true, the result is false, and vice versa. Commonly used to reverse a condition. For example, if a feature is enabled, you might use the NOT operator to determine if it should be disabled.

Here's how it works:

  • Evaluates the operand.
  • If the operand is true, the result is false.
  • If the operand is false, the result is true.
class Program
{
    static void Main(string[] args)
    {
        bool isLoggedOn = false;
        bool showLoginButton = !isLoggedOn;
        Console.WriteLine(showLoginButton); // Output: true
    }
}
class Program
{
    static void Main(string[] args)
    {
        bool isLoggedOn = false;
        bool showLoginButton = !isLoggedOn;
        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
		Console.WriteLine(showLoginButton) ' Output: true
	End Sub
End Class
VB   C#

Here, since isLoggedOn is false, the logical NOT operator returns true.

Combining with Other Operators

The NOT operator can be used with AND and OR operators to create more complex conditions.

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

 hasVacation);
Console.WriteLine(isWorkDay); // Output: false
bool isWeekend = false;
bool hasVacation = true;
bool isWorkDay = !(isWeekend 

 hasVacation);
Console.WriteLine(isWorkDay); // Output: false
Dim isWeekend As Boolean = False
Dim hasVacation As Boolean = True
Dim isWorkDay As Boolean = Not (isWeekend hasVacation)
Console.WriteLine(isWorkDay) ' Output: false
VB   C#

4. 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.

The XOR operator compares the two operands. If they are different, it returns true. If they are the same, it returns false.

class Program
{
    static void Main(string[] args)
    {
        bool hasPassword = true;
        bool hasSmartCard = false;
        bool canLogin = hasPassword ^ hasSmartCard;
        Console.WriteLine(canLogin); // Output: true
    }
}
class Program
{
    static void Main(string[] args)
    {
        bool hasPassword = true;
        bool hasSmartCard = false;
        bool canLogin = hasPassword ^ hasSmartCard;
        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
		Console.WriteLine(canLogin) ' Output: true
	End Sub
End Class
VB   C#

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 Operators

Compound assignment operators combine arithmetic with the assignment. They're shorthand for performing an operation and assigning the result to the variable.

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
VB   C#

Types of Compound Assignment Operators

  1. +=: Add and assign
  2. -=: Subtract and assign
  3. *`=`**: Multiply and assign
  4. /=: Divide and assign
  5. %=: Modulus and assign
  6. &=: Bitwise AND and assign
  7. =: Bitwise OR and assign
  8. ^=: Bitwise XOR and assign

Arithmetic Operators

Arithmetic operators perform standard mathematical operations.

Types of Arithmetic Operators

  1. +: Addition
  2. -: Subtraction
  3. *``**: Multiplication
  4. /: Division
  5. %: 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.

In C#, logical operators have specific precedence:

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

Bitwise Logical Operators

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

Types of Bitwise Logical Operators

  1. &: Bitwise AND
  2. |: Bitwise OR
  3. ^: Bitwise XOR
  4. ~: Bitwise NOT
  5. <<: Left Shift
  6. >>: Right Shift

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

Iron Suite A Powerful Toolkit for C#

The Iron Suite is a collection of libraries tailored to extend the functionalities of C# programming. This remarkable set of tools can assist developers in a wide array of tasks, such as document processing, data handling, and text recognition. Let's explore each component of the Iron Suite

IronPDF C#

IronPDF enables developers to create, read, edit, and convert PDF documents within a C# application. But how does it connect with logical operators?

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.

Want to convert HTML to PDF? Check out this HTML to PDF tutorial.

IronXL Excel Handling with Precision

IronXL simplifies working with Excel files, allowing you to read, write, and manipulate Excel 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.

IronOCR Optical Character Recognition

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.

IronBarcode Barcode Generation and Reading

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.

Conclusion

The Iron Suit's remarkable toolkit of IronPDF, IronXL, IronOCR, and IronBarcode showcases how foundational programming concepts like logical operators can be harnessed to unlock powerful functionalities in real-world applications.

Whether you're a beginner exploring the fascinating world of logical operations in C# or a seasoned professional, these tools can greatly enhance your development process.

The good news is that each product in the Iron Suit offers a free trial, allowing you to explore and test these tools without any financial commitment. If you find they fit your needs, licensing starts from just $749 per product.

Even better, you can purchase the full Iron Suite for the price of just two individual products. It's a great opportunity to access a suite of tools that can transform how you work with documents, data, text recognition, and barcodes within your C# applications.