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

Il est essentiel de comprendre les opérateurs logiques lorsque l'on travaille avec des instructions conditionnelles en programmation. Des opérations XOR aux opérations arithmétiques, elles jouent un rôle essentiel dans la détermination de la valeur de vérité des conditions données.

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

Que sont les opérateurs logiques ?

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

Ci-dessous, nous examinerons les différents opérateurs logiques en C#, en comprenant leurs fonctions et en montrant comment vous pouvez intégrer l'opérateur logique dans vos applications pour effectuer des opérations logiques avec précision et efficacité.

Types d'opérateurs logiques en C# ;

Opérateur ET logique (&&)

L'opérateur logique ET(&&) combine deux expressions booléennes et renvoie un résultat vrai si les deux sont vraies. Si l'un ou l'autre ou les deux sont faux, le résultat est faux. Couramment utilisé dans les scénarios à conditions multiples où toutes les conditions doivent être remplies. Par exemple, il s'agit de vérifier si l'utilisateur est suffisamment âgé et s'il dispose d'un solde suffisant pour effectuer un achat.

L'opérateur && :

• Évalue l'opérande gauche
• Si l'opérande gauche est faux, l'expression entière est fausse.
• Si l'opérande gauche est vrai, l'opérande droit est évalué

• L'expression est vraie si les deux opérandes sont vrais.

  Si l'opérande gauche est faux, l'opérande droit n'est pas évalué, car l'expression entière est garantie comme étant fausse.

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dans cet exemple, bien que isAdult soit vrai, hasBalance est faux, donc le résultat est faux.

Opérateur logique OU (

)

L'opérateur logique OR(

) combine deux expressions booléennes et renvoie un résultat vrai si au moins l'une d'entre elles est vraie. Si les deux sont faux, le résultat est faux. Idéal pour les scénarios dans lesquels au moins une des conditions doit être remplie. Par exemple, autoriser l'entrée d'une personne si elle est membre ou si elle possède un billet.

Les

opérateur:

• Évalue l'opérande gauche
• Si l'opérande gauche est vrai, toute l'expression est vraie
• Si l'opérande gauche est faux, l'opérande droit est évalué

• L'expression est vraie si l'un des opérandes est vrai.

  Si l'opérande gauche est vrai, l'opérande droit n'est pas évalué, car l'expression entière est garantie vraie.

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

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

Opérateur logique NON (!)

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. Utilisé couramment pour inverser une condition. Par exemple, si une fonctionnalité est activée, vous pouvez 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;
       Console.WriteLine(showLoginButton); // Output: true
   }
}

class Program
{
   static void Main(string [] args)
   {
       bool isLoggedOn = false;
       bool showLoginButton = !isLoggedOn;
       Console.WriteLine(showLoginButton); // Output: true
   }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

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);
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

Opérateur XOR Logique (^)

L'opérateur logique XOR(^) retourne vrai si les deux opérandes ont des valeurs différentes. Si les deux sont identiques, il renvoie false. Cet opérateur est particulièrement utile lorsque vous voulez vous assurer que l'une 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;
       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
   }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Étant donné que les valeurs de hasPassword et de hasSmartCard sont différentes, l'opérateur logique XOR retourne true. Si les deux étaient vrais ou faux, il renverrait faux.

Autres opérateurs apparentés

Opérateur d'assignation composée

Un opérateur d'affectation composé combine l'arithmétique avec l'affectation. Il s'agit d'un raccourci pour effectuer une opération et assigner le résultat à la variable. Voici quelques types d'opérateurs d'affectation composés :

• += : Ajouter et assigner
• -=: Soustraire et assigner
• *=: Multiplier et attribuer
• /=: Diviser et attribuer
• %=: Modulus et assigner
• &=: ET bit à bit et assigner
• : OU binaire et affectation

• ^=: 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

Opérateurs arithmétiques

Les opérateurs arithmétiques effectuent des opérations mathématiques standard. Il s'agit notamment de

• +: Addition
• • : Soustraction
• • : Multiplication
• / : Division
• % : Modulo(reste de la division)

Priorité de l'opérateur

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# :

• Logique NON(!)
• Multiplicatif(*, /, %)
• Additif(+, -)
• Test de relation et de type <, >, <=, >=, is, as)
• L'égalité(==,!=)
• ET logique(&&)

• OU logique(

  )

Opérateurs binaires

Outre les opérateurs logiques qui travaillent sur des valeurs booléennes, certains opérateurs logiques bitwise travaillent sur la représentation binaire des nombres entiers. Les types d'opérateurs logiques binaires sont :

• & : ET bit à bit
• : OU bit à bit
• ^ : XOR bit à bit
• ~: NON bit à bit
• <<: Décalage à gauche

• >>: Décalage à droite

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

Iron Suite : A Powerful Toolkit for C&num ;

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

IronPDF

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

Découvrez comment IronPDF améliore le traitement 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, l'opérateur logique ET permet de filtrer les enregistrements qui répondent à plusieurs critères ou l'opérateur logique OU permet de sélectionner les lignes qui répondent à plusieurs conditions.

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

IronOCR

IronOCR est un outil puissant qui permet à votre application C# de reconnaître et de lire le texte des 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 logiques NOT, AND et OR, vous pouvez créer des règles de validation complexes pour garantir l'exactitude des données.

Découvrez 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 le type de code-barres à développer ou à lire en fonction de conditions spécifiques ou pour valider les données du code-barres selon certaines règles logiques.

Découvrez comment IronBarcode gère les opérations liées aux codes-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 laIron Suite pour le développement C#, vous pouvez voir quelques exemples pratiques d'utilisation des opérateurs logiques dans des applications du monde réel.

Si vous souhaitez pratiquer vos compétences en C#, chaque produit de l'Iron Suite est complètement gratuit à utiliser dans un environnement de développement. Que vous commenciez tout juste ou que vous soyez déjà un expert en C#, ces outils peuvent vous aider à amener votre code au niveau supérieur.