C# Logische Operatoren (Wie es für Entwickler funktioniert)

Logischer UND-Operator (&&)

Der logische UND-Operator (&&) kombiniert zwei boolesche Ausdrücke und gibt wahr zurück, wenn beide wahr sind. Wenn einer oder beide falsch sind, ist das Ergebnis falsch. Wird häufig in Mehrbedingungsszenarien verwendet, bei denen alle Bedingungen erfüllt sein müssen. Zum Beispiel, wenn validiert wird, ob ein Benutzer alt genug ist und genug Guthaben hat, um zu kaufen.

Der && Operator:

• Bewertet den linken Operanden
• Wenn der linke Operand falsch ist, ist der gesamte Ausdruck falsch
• Wenn der linke Operand wahr ist, wird der rechte Operand bewertet
• Der Ausdruck ist wahr, wenn beide Operanden wahr sind

Wenn der linke Operand falsch ist, wird der rechte Operand nicht ausgewertet, da der gesamte Ausdruck als falsch garantiert ist.

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 diesem Beispiel ist zwar isAdult wahr, aber hasBalance ist falsch, daher ist das Ergebnis falsch.

Logischer OR-Operator (

Der logische ODER-Operator (||) kombiniert zwei boolesche Ausdrücke und gibt wahr zurück, wenn mindestens einer wahr ist. Wenn beide falsch sind, ist das Ergebnis falsch. Ideal für Szenarien, in denen mindestens eine von mehreren Bedingungen wahr sein muss. Zum Beispiel, wenn ein Zutritt erlaubt ist, wenn eine Person Mitglied ist oder ein Ticket hat.

Der || Operator:

• Bewertet den linken Operanden
• Wenn der linke Operand wahr ist, ist der gesamte Ausdruck wahr
• Wenn der linke Operand falsch ist, wird der rechte Operand ausgewertet
• Der Ausdruck ist wahr, wenn mindestens ein Operand wahr ist

Wenn der linke Operand wahr ist, wird der rechte Operand nicht ausgewertet, da der gesamte Ausdruck als wahr garantiert ist.

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

Da hier isMember wahr ist, wird hasTicket gar nicht erst ausgewertet, und das Ergebnis ist wahr.

Logischer 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

Logischer XOR-Operator (^)

Da die Werte von hasPassword und hasSmartCard unterschiedlich sind, gibt der XOR wahr zurück. Wenn beide gleich sind, gibt er falsch zurück. Dieser Operator ist besonders nützlich, wenn Sie sicherstellen möchten, dass genau eine von zwei Bedingungen wahr ist, aber nicht beide.

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

Da die Werte von hasPassword und hasSmartCard unterschiedlich sind, gibt die logische XOR-Verknüpfung "wahr" zurück. Wenn beide wahr oder beide falsch wären, würde es falsch zurückgeben.

Zusammengesetzter Zuweisungsoperator

Ein zusammengesetzter Zuweisungsoperator kombiniert Arithmetik mit der Zuweisung. Sie sind eine Kurzform für die Durchführung einer Operation und die Zuweisung des Ergebnisses an die Variable. Hier sind einige Arten von zusammengesetzten Zuweisungsoperatoren:

• +=: Hinzufügen und Zuweisen
• -=: Subtrahieren und zuweisen
• *=: Multiplizieren und zuweisen
• /=: Teilen und Zuweisen
• %=: Modulo und Zuweisung
• &=: Bitweises UND und Zuweisung
• |=: Bitweises ODER und Zuweisung
• ^=: Bitweises XOR und Zuweisung

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

Arithmetische Operatoren

Arithmetische Operatoren führen mathematische Standardoperationen aus. Sie beinhalten:

• +: Addition
• -: Subtraktion
• *: Multiplikation
• /: Division
• %: Modulo (Rest der Division)

Vorrang von Operatoren

Der Operatorvorrang definiert die Reihenfolge, in der Operationen in einem Ausdruck ausgeführt werden. Zum Beispiel werden Multiplikation und Division vor Addition und Subtraktion ausgeführt.

Hier ist die Reihenfolge des Operatorvorrangs in C#:

1. Logisches NOT (!)
2. Multiplikativ (*, /, %)
3. Additiv (+, -)
4. Relational und Typprüfung (<, >, <=, >=, is, as)
5. Gleichheit (==, !=)
6. Logisches UND (&&)
7. Logisches ODER (||)

Bitweise Operatoren

Neben den logischen Operatoren, die auf boolesche Werte wirken, funktionieren einige bitweise logische Operatoren auf der binären Darstellung von Ganzzahlen. Die Arten der bitweisen logischen Operatoren sind:

• &: Bitweises UND
• |: Bitweises ODER
• ^: Bitweises XOR
• ~: Bitweises NOT
• <<: Linksshift
• >>: Rechtsshift

Diese bitweisen Operatoren ermöglichen es Ihnen, einzelne Bits innerhalb eines Integerwerts zu manipulieren.

IronPDF

IronPDF ermöglicht Entwicklern, PDF-Dokumente innerhalb einer C#-Anwendung zu erstellen, zu lesen, zu bearbeiten und zu konvertieren. Betrachten Sie ein Szenario, in dem Sie spezifische Informationen aus einem PDF basierend auf bestimmten Bedingungen filtern und extrahieren müssen. Logische Operatoren können verwendet werden, um diese Bedingungen zu definieren, sodass das Programm intelligente Entscheidungen darüber treffen kann, welche Daten extrahiert oder manipuliert werden sollen.

Erfahren Sie, wie IronPDF die Handhabung von PDF-Dokumenten verbessert.

IronXL

IronXL vereinfacht die Arbeit mit Microsoft Excel-Dateien und ermöglicht es Ihnen, Tabellenkalkulationen direkt in C# zu lesen, zu schreiben und zu manipulieren. Sie können logische Operatoren nutzen, um dynamische Bedingungen beim Verarbeiten von Daten zu erstellen. Beispielsweise können Sie den logischen UND-Operator verwenden, um Datensätze zu filtern, die mehrere Kriterien erfüllen, oder den logischen ODER-Operator verwenden, um Zeilen auszuwählen, die mehrere Bedingungen erfüllen.

Erfahren Sie mehr über die Arbeit mit Excel mithilfe von IronXL.

IronOCR

IronOCR ist ein leistungsstarkes Tool, das Ihrer C#-Anwendung ermöglicht, Text aus Bildern zu erkennen und zu lesen. Logische Operatoren können beim Nachbearbeiten des extrahierten Texts helfen. Stellen Sie sich einen Anwendungsfall vor, in dem Sie die extrahierten Informationen validieren müssen.

Sehen Sie, wie IronOCR optische Zeichenerkennung ermöglicht.

IronBarcode

Verwenden Sie logische Operatoren, um zu bestimmen, welcher Barcode erzeugt oder gelesen werden soll, und um Barcodedaten gemäß logischen Regeln zu validieren. Sie können logische Operatoren verwenden, um zu bestimmen, welchen Barcode Sie basierend auf bestimmten Bedingungen entwickeln oder lesen oder um Barcodedaten gemäß bestimmten logischen Regeln zu validieren.

Erfahren Sie, wie IronBarcode Barcode-Operationen verwaltet.