Comprendre les opérateurs logiques est essentiel lorsque vous travaillez avec des instructions conditionnelles en programmation. Des opérations XOR aux opérations arithmétiques, ils jouent un rôle vital dans la détermination de la valeur de vérité de conditions données.

Ce guide vous guidera à travers les fondamentaux des opérateurs logiques en C#, y compris des concepts tels que les valeurs booléennes, la préséance des opérateurs, la négation logique, et bien plus encore.

Quels sont les opérateurs logiques ?

Les opérateurs logiques, communément appelés opérations logiques, forment le cœur de la prise de décision en programmation. Ils opèrent sur des expressions booléennes, les évaluent pour produire une valeur booléenne de vrai ou faux, selon les conditions fournies. Ces opérateurs jouent un rôle crucial dans le contrôle du flux de votre programme, vous permettant d'exécuter des blocs de code spécifiques en fonction de certains critères.

Ci-dessous, nous allons plonger dans les différents opérateurs logiques en C#, comprendre leurs fonctions et montrer comment vous pouvez intégrer des opérateurs logiques dans vos applications pour effectuer des opérations logiques avec précision et efficacité.

Types of Logical Operators in C#

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
    }
}

Module Program
    Sub Main(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 Module

Module Program
    Sub Main(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 Module

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
    }
}

Module Program
    Sub Main(args As String())
        Dim isMember As Boolean = True
        Dim hasTicket As Boolean = False
        Dim canEnter As Boolean = isMember Or hasTicket

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

Module Program
    Sub Main(args As String())
        Dim isMember As Boolean = True
        Dim hasTicket As Boolean = False
        Dim canEnter As Boolean = isMember Or hasTicket

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

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

Opérateur logique NOT (!)

L'opérateur logique NOT (!) inverse la valeur d'une expression booléenne. Si l'opérande est vrai, le résultat est faux, et vice versa. Couramment utilisé pour inverser une condition. Par exemple, si une fonctionnalité est activée, vous pourriez utiliser l'opérateur NOT pour déterminer si elle doit être désactivée.

Voici comment cela fonctionne :

• Évalue l'opérande.
• Si l'opérande est vrai, le résultat est faux.
• Si l'opérande est faux, le résultat est vrai.

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
    }
}

Module Program
    Sub Main(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 Module

Module Program
    Sub Main(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 Module

Ici, puisque isLoggedOn est faux, l'opérateur logique NOT retourne vrai.

Combinaison avec d'autres opérateurs

L'opérateur NOT peut être utilisé avec les opérateurs AND et OR pour créer des conditions plus complexes.

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

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
    }
}

Module Program
    Sub Main(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 Module

Module Program
    Sub Main(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 Module

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.

Autres opérateurs connexes

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 assigner
• -= : Soustraire et assigner
• *= : Multiplier et assigner
• /= : Diviser et assigner
• %= : Modulo et assigner
• &= : AND bit à bit et assigner
• |= : OU binaire et affecter
• ^= : XOR bit à bit et assigner

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

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
• % : Modulo (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 Bitwise

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 :

• & : AND 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.

Iron Suite: A Powerful Toolkit for C#

La Iron Suite pour le développement C# est une collection de bibliothèques conçues pour étendre les fonctionnalités de la programmation C#. Cet ensemble d'outils remarquable peut aider les développeurs dans une large gamme de tâches, telles que le traitement de documents, la gestion des données et la reconnaissance de texte. Explorons comment chaque produit profite des opérateurs logiques.

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.

Conclusion

Les opérateurs logiques sont une compétence indispensable pour tout programmeur en herbe, et ce guide n'est qu'un aperçu de ce que les opérateurs C# peuvent faire. Avec le Iron Suite pour le développement C#, vous pouvez voir des exemples pratiques d'utilisation des opérateurs logiques dans des applications réelles.

Si vous cherchez à pratiquer vos compétences en C#, chaque produit dans l'Iron Suite est entièrement gratuit à utiliser dans un environnement de développement. Que vous débutiez ou que vous soyez déjà un pro de C#, ces outils peuvent vous aider à passer au niveau supérieur en programmation.