Operadores lógicos em C# (Como funcionam para desenvolvedores)

Operador lógico AND (&&)

O operador lógico AND (&&) combina duas expressões booleanas e retorna verdadeiro se ambas forem verdadeiras. Se uma ou ambas forem falsas, o resultado será falso. Comumente utilizado em cenários com múltiplas condições, onde todas as condições devem ser atendidas. Por exemplo, verificar se um usuário tem idade suficiente e saldo suficiente para efetuar a compra.

O operador &&:

• Avalia o operando esquerdo
• Se o operando da esquerda for falso, toda a expressão será falsa.
• Se o operando da esquerda for verdadeiro, o operando da direita será avaliado.
• A expressão é verdadeira se ambos os operandos forem verdadeiros.

Se o operando da esquerda for falso, o operando da direita não será avaliado, pois é garantido que toda a expressão será falsa.

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

Neste exemplo, embora isAdult seja verdadeiro, hasBalance é falso, portanto o resultado é falso.

Operador lógico OU (

O operador lógico OU (||) combina duas expressões booleanas e retorna verdadeiro se pelo menos uma delas for verdadeira. Se ambas forem falsas, o resultado será falso. Ideal para cenários onde pelo menos uma das várias condições deve ser verdadeira. Por exemplo, permitir a entrada se a pessoa for membro ou tiver um ingresso.

O operador ||

• Avalia o operando esquerdo
• Se o operando da esquerda for verdadeiro, toda a expressão será verdadeira.
• Se o operando da esquerda for falso, o operando da direita será avaliado.
• A expressão é verdadeira se qualquer um dos operandos for verdadeiro.

Se o operando da esquerda for verdadeiro, o operando da direita não será avaliado, pois toda a expressão tem garantia de ser verdadeira.

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

Aqui, como isMember é verdadeiro, hasTicket nem sequer é avaliado, e o resultado é verdadeiro.

Operador lógico NÃO (!)

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

Operador XOR lógico (^)

O operador lógico XOR (^) retorna verdadeiro se os dois operandos tiverem valores diferentes. Se ambos forem iguais, retorna falso. Este operador é particularmente útil quando se deseja garantir que exatamente uma das duas condições seja verdadeira, mas não ambas.

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

Como os valores de hasPassword e hasSmartCard são diferentes, o XOR lógico retorna verdadeiro. Se ambas as condições fossem verdadeiras ou ambas fossem falsas, o resultado seria falso.

Operador de Atribuição Composta

Um operador de atribuição composto combina aritmética com a atribuição. São abreviações para realizar uma operação e atribuir o resultado a uma variável. Aqui estão alguns tipos de operadores de atribuição composta:

• +=: Adicionar e atribuir
• -=: Subtrair e atribuir
• *=: Multiplique e atribua
• /=: Dividir e atribuir
• %=: Módulo e atribuição
• &=: AND bit a bit e atribuição
• |=: OU bit a bit e atribuição
• ^=: XOR bit a bit e atribuição

E aqui estão eles em ação:

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

Operadores Aritméticos

Os operadores aritméticos executam operações matemáticas padrão. Eles incluem:

• +: Adição
• -: Subtração
• *: Multiplicação
• /: Divisão
• %: Módulo (resto da divisão)

Precedência do operador

A precedência de operadores define a ordem em que as operações são executadas em uma expressão. Por exemplo, a multiplicação e a divisão são realizadas antes da adição e da subtração.

Aqui está a ordem de precedência dos operadores em C#:

1. Negação lógica (!)
2. Multiplicativo (*, /, %)
3. Aditivo (+, -)
4. Testes relacionais e de tipo (<, >, <=, >=, é, como)
5. Igualdade (==, !=)
6. Operador lógico AND (&&)
7. OU lógico (||)

Operadores bit a bit

Além dos operadores lógicos que atuam sobre valores booleanos, alguns operadores lógicos bit a bit atuam sobre a representação binária de números inteiros. Os tipos de operadores lógicos bit a bit são:

• &: AND bit a bit
• |: OU bit a bit
• ^: XOR bit a bit
• ~: Negação bit a bit
• <<: Deslocamento para a esquerda
• >>: Deslocamento para a direita

Esses operadores bit a bit permitem manipular bits individuais dentro de um valor inteiro.

IronPDF

O IronPDF permite que desenvolvedores criem, leiam, editem e convertam documentos PDF dentro de um aplicativo C#. Considere um cenário em que você precisa filtrar e extrair informações específicas de um PDF com base em determinadas condições. Operadores lógicos podem ser empregados para definir essas condições, permitindo que o programa tome decisões inteligentes sobre quais dados extrair ou manipular.

Descubra como o IronPDF aprimora o manuseio de documentos PDF .

IronXL

IronXL simplifica o trabalho com arquivos do Microsoft Excel, permitindo que você leia, escreva e manipule planilhas diretamente em C#. Você pode utilizar operadores lógicos para criar condições dinâmicas durante o processamento de dados. Por exemplo, usar o operador lógico AND para filtrar registros que atendam a vários critérios ou usar o operador lógico OR para selecionar linhas que atendam a várias condições.

Aprenda a trabalhar com o Excel usando o IronXL .

IronOCR

IronOCR é uma ferramenta poderosa que permite que seu aplicativo C# reconheça e leia texto em imagens. Os operadores lógicos podem desempenhar um papel no pós-processamento do texto extraído. Imagine um caso de uso em que você precise validar as informações extraídas. Utilizando os operadores lógicos NOT, AND e OR, você pode criar regras de validação complexas para garantir a precisão dos dados.

Veja como o IronOCR possibilita o reconhecimento óptico de caracteres .

IronBarcode

IronBarcode adiciona a capacidade de gerar, ler e reconhecer códigos de barras em um aplicativo C#. Você pode usar operadores lógicos para determinar qual tipo de código de barras desenvolver ou ler com base em condições específicas ou para validar dados de código de barras de acordo com determinadas regras lógicas.

Descubra como a IronBarcode gerencia operações de código de barras .