Opérateurs logiques en C# (Comment ça fonctionne pour les développeurs)

Opérateur logique AND (&&)

L'opérateur logique AND (&&) combine deux expressions booléennes et retourne vrai si les deux sont vraies. Si l'une ou les deux sont fausses, le résultat est faux. Couramment utilisé dans des scénarios à conditions multiples où toutes les conditions doivent être remplies. Par exemple, valider si un utilisateur est assez âgé et a suffisamment de solde pour acheter.

L'opérateur && :

• Évalue l'opérande de gauche
• Si l'opérande de gauche est faux, l'expression entière est fausse
• Si l'opérande de gauche est vrai, l'opérande de droite est évalué
• L'expression est vraie si les deux opérandes sont vrais

Si l'opérande de gauche est faux, l'opérande de droite n'est pas évalué, car l'expression entière est garantie d'être fausse.

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

Dans cet exemple, même si isAdult est vrai, hasBalance est faux, donc le résultat est faux.

Opérateur logique OR (

L'opérateur logique OR (||) combine deux expressions booléennes et retourne vrai si au moins l'une est vraie. Si les deux sont fausses, le résultat est faux. Idéal pour les scénarios où au moins une de plusieurs conditions doit être vraie. Par exemple, autoriser l'entrée si une personne est membre ou a un billet.

L'opérateur || :

• Évalue l'opérande de gauche
• Si l'opérande de gauche est vrai, l'expression entière est vraie
• Si l'opérande de gauche est faux, l'opérande de droite est évalué
• L'expression est vraie si l'un des opérandes est vrai

Si l'opérande de gauche est vrai, l'opérande de droite n'est pas évalué, car l'expression entière est garantie d'être vraie.

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

Ici, puisque isMember est vrai, hasTicket n'est même pas évalué, et le résultat est vrai.

Opérateur logique NOT (!)

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

Opérateur logique XOR (^)

L'opérateur logique XOR (^) retourne vrai si les deux opérandes ont des valeurs différentes. Si les deux sont identiques, il retourne faux. Cet opérateur est particulièrement utile lorsque vous voulez vous assurer qu'une seule des deux conditions est vraie, mais pas les deux.

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

Puisque les valeurs de hasPassword et hasSmartCard sont différentes, le XOR logique retourne vrai. Si les deux étaient vrais ou les deux étaient faux, il retournerait faux.

Opérateur d'affectation composée

Un opérateur d'affectation composée combine une opération arithmétique avec l'affectation. Ils sont une version raccourcie pour effectuer une opération et affecter le résultat à la variable. Voici quelques types d'opérateurs d'affectation composée :

• += : Ajouter et affecter
• -= : Soustraire et affecter
• *=: Multiplier et affecter
• /= : Diviser et affecter
• %= : Modulus et affecter
• &= : ET binaire et affecter
• |= : OU binaire et affecter
• ^= : XOR binaire et affecter

Et les voici en 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

Opérateurs arithmétiques

Les opérateurs arithmétiques effectuent des opérations mathématiques standards. Ils incluent :

• + : Addition
• - : Soustraction
• * : Multiplication
• / : Division
• % : Modulus (reste de la division)

Priorité des opérateurs

La priorité des opérateurs définit l'ordre dans lequel les opérations sont effectuées dans une expression. Par exemple, la multiplication et la division sont effectuées avant l'addition et la soustraction.

Voici l'ordre de priorité des opérateurs en C# :

1. NON logique (!)
2. Multiplicatif (*, /, %)
3. Additif (+, -)
4. Relationnel et test de type (<, >, <=, >=, is, as)
5. Égalité (==, !=)
6. ET logique (&&)
7. OU logique (||)

Opérateurs bit-à-bit

En dehors des opérateurs logiques qui fonctionnent sur des valeurs booléennes, certains opérateurs logiques bit-à-bit fonctionnent sur la représentation binaire des entiers. Les types d'opérateurs logiques bit-à-bit sont :

• & : ET bit-à-bit
• | : OU bit-à-bit
• ^ : XOR bit-à-bit
• ~ : NOT bit-à-bit
• << : Décalage à gauche
• >> : Décalage à droite

Ces opérateurs bit-à-bit vous permettent de manipuler des bits individuels au sein d'une valeur entière.

IronPDF

IronPDF permet aux développeurs de créer, lire, éditer et convertir des documents PDF dans une application C#. Considérez un scénario où vous devez filtrer et extraire des informations spécifiques d'un PDF en fonction de certaines conditions. Les opérateurs logiques peuvent être utilisés pour définir ces conditions, permettant au programme de prendre des décisions intelligentes sur les données à extraire ou à manipuler.

Découvrez comment IronPDF améliore la gestion des documents PDF.

IronXL

IronXL simplifie le travail avec les fichiers Microsoft Excel, vous permettant de lire, écrire et manipuler des feuilles de calcul directement en C#. Vous pouvez utiliser des opérateurs logiques pour créer des conditions dynamiques lors du traitement des données. Par exemple, utiliser l'opérateur logique AND pour filtrer les enregistrements qui répondent à plusieurs critères ou utiliser l'opérateur logique OR pour sélectionner les lignes qui répondent à plusieurs conditions.

Apprenez à travailler avec Excel à l'aide d'IronXL.

IronOCR

IronOCR est un outil puissant qui permet à votre application C# de reconnaître et lire le texte à partir d'images. Les opérateurs logiques peuvent jouer un rôle dans le post-traitement du texte extrait. Imaginez un cas d'utilisation où vous devez valider les informations extraites. En utilisant les opérateurs NOT, AND, OR logiques, vous pouvez créer des règles de validation complexes pour assurer la précision des données.

Voyez comment IronOCR permet la reconnaissance optique de caractères.

IronBarcode

IronBarcode ajoute la capacité de générer, lire et reconnaître des codes-barres au sein d'une application C#. Vous pouvez utiliser des opérateurs logiques pour déterminer quel type de code-barres développer ou lire en fonction de conditions spécifiques ou pour valider les données de code-barres selon certaines règles logiques.

Découvrez comment IronBarcode gère les opérations de code-barres.