Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Boolean structure

 

Date de publication : novembre 2016

Représente une valeur booléenne (true ou false).

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Boolean : IComparable, IConvertible, IComparable<bool>, 
	IEquatable<bool>

NomDescription
System_CAPS_pubmethodCompareTo(Boolean)

Compare cette instance à un objet Boolean spécifié et retourne un entier qui indique la relation entre ces deux éléments.

System_CAPS_pubmethodCompareTo(Object)

Compare cette instance à l'objet spécifié et retourne un entier qui indique la relation entre ces deux éléments.

System_CAPS_pubmethodEquals(Boolean)

Retourne une valeur indiquant si cette instance est égale à un objet Boolean spécifié.

System_CAPS_pubmethodEquals(Object)

Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.(Remplace ValueType.Equals(Object).)

System_CAPS_pubmethodGetHashCode()

Retourne le code de hachage de cette instance.(Remplace ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodGetTypeCode()

Retourne le code de type pour le type valeur Boolean.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Convertit la représentation sous forme de chaîne spécifiée d’une valeur logique en son équivalent Boolean.

System_CAPS_pubmethodToString()

Convertit la valeur de cette instance en sa représentation sous forme de chaîne équivalente ("True" ou "False").(Remplace ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Convertit la valeur de cette instance en sa représentation sous forme de chaîne équivalente ("True" ou "False").

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Boolean)

Tente de convertir la représentation sous forme de chaîne d'une valeur logique en son Boolean équivalent. Une valeur de retour indique si la conversion a réussi ou a échoué.

NomDescription
System_CAPS_pubfieldSystem_CAPS_staticFalseString

Représente la valeur booléenne false sous forme de chaîne. Ce champ est en lecture seule.

System_CAPS_pubfieldSystem_CAPS_staticTrueString

Représente la valeur booléenne true sous forme de chaîne. Ce champ est en lecture seule.

NomDescription
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt64.

A Boolean instance peut avoir une des deux valeurs : true, ou false.

Le Boolean structure fournit des méthodes qui prennent en charge les tâches suivantes :

  • Convertir des valeurs booléennes en chaînes :ToString

  • Analyser des chaînes pour les convertir en valeurs booléennes : Parse etTryParse

  • Comparaison de valeurs : CompareTo etEquals

Les sections suivantes expliquent ces tâches et autres détails d’utilisation :

Mise en forme des valeurs booléennes
Conversion entre des valeurs booléennes
L’analyse des valeurs booléennes
Comparaison des valeurs booléennes
Utilisation des valeurs booléennes en tant que valeurs binaires
Exécution d’opérations avec des valeurs booléennes
Valeurs booléennes et l’interopérabilité

La représentation sous forme de chaîne d’un Boolean est soit « True » pour un true valeur ou « False » pour un false valeur. La représentation sous forme de chaîne d’un Boolean valeur est définie en lecture seule TrueString et FalseString champs.

Vous utilisez la ToString méthode pour convertir des valeurs booléennes en chaînes. La structure booléenne inclut deux ToString surcharges : sans paramètre ToString() (méthode) et le ToString(IFormatProvider) (méthode), qui inclut un paramètre qui contrôle la mise en forme. Toutefois, étant donné que ce paramètre est ignoré, les deux surcharges produisent des chaînes identiques. Le ToString(IFormatProvider) (méthode) ne prend pas en charge la mise en forme dépendante de la culture.

L’exemple suivant illustre la mise en forme avec la ToString (méthode). Notez que l’exemple utilise le mise en forme composite fonctionnalité, donc la ToString méthode est appelée implicitement.

using System;

public class Example
{
   public static void Main()
   {
      bool raining = false;
      bool busLate = true;

      Console.WriteLine("It is raining: {0}", raining);
      Console.WriteLine("The bus is late: {0}", busLate);
   }
}
// The example displays the following output:
//       It is raining: False
//       The bus is late: True

Étant donné que le Boolean structure peut avoir uniquement deux valeurs, il est facile d’ajouter la mise en forme personnalisée. Pour la simple mise en forme personnalisée dans une autre chaîne littéraux sont substitués pour « True » et « False », vous pouvez utiliser n’importe quelle fonctionnalité évaluation conditionnelle pris en charge par votre langage, telles que la opérateur conditionnel en c# ou le si opérateur en Visual Basic. L’exemple suivant utilise cette technique pour le formatage de Boolean les valeurs « Oui » et « No » plutôt que « True » et « False ».

using System;

public class Example
{
   public static void Main()
   {
      bool raining = false;
      bool busLate = true;

      Console.WriteLine("It is raining: {0}", 
                        raining ? "Yes" : "No");
      Console.WriteLine("The bus is late: {0}", 
                        busLate ? "Yes" : "No" );
   }
}
// The example displays the following output:
//       It is raining: No
//       The bus is late: Yes

Pour les opérations de mise en forme personnalisées plus complexes, y compris la mise en forme dépendante de la culture, vous pouvez appeler la String.Format(IFormatProvider, String, Object[]) méthode et fournir une ICustomFormatter implémentation. L’exemple suivant implémente la ICustomFormatter et IFormatProvider interfaces pour fournir des chaînes de type Boolean dépendante de la culture pour l’anglais (États-Unis), Français (France) et cultures de russe (Russie).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "", "en-US", "fr-FR", "ru-RU" };
      foreach (var cultureName in cultureNames) {
         bool value = true;
         CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
         BooleanFormatter formatter = new BooleanFormatter(culture);

         String result = String.Format(formatter, "Value for '{0}': {1}", culture.Name, value);
         Console.WriteLine(result);
      }
   }
}

public class BooleanFormatter : ICustomFormatter, IFormatProvider
{   
   private CultureInfo culture;

   public BooleanFormatter() : this(CultureInfo.CurrentCulture)
   { }

   public BooleanFormatter(CultureInfo culture)
   {
      this.culture = culture; 
   }

   public Object GetFormat(Type formatType)
   { 
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }

   public String Format(String fmt, Object arg, IFormatProvider formatProvider)
   { 
      // Exit if another format provider is used.
      if (! formatProvider.Equals(this)) return null;

      // Exit if the type to be formatted is not a Boolean
      if (! (arg is Boolean)) return null;

      bool value = (bool) arg;
      switch (culture.Name) {
         case "en-US":
            return value.ToString();
         case "fr-FR":
            if (value) 
               return "vrai";
            else
               return "faux";
         case "ru-RU":
            if (value)
               return "верно";
            else
               return "неверно";
         default:
            return value.ToString();  
      }
   }
}
// The example displays the following output:
//       Value for '': True
//       Value for 'en-US': True
//       Value for 'fr-FR': vrai
//       Value for 'ru-RU': верно

Si vous le souhaitez, vous pouvez utiliser les fichiers de ressources pour définir des chaînes de type Boolean spécifiques à la culture.

Le Boolean structure implémente la IConvertible interface. Par conséquent, vous pouvez utiliser la Convert classe pour effectuer des conversions entre un Boolean valeur et tout autre type primitif dans le .NET Framework, ou vous peuvent appeler la Boolean implémentations explicites de la structure. Toutefois, les conversions entre un Boolean et les éléments suivants types ne sont pas pris en charge, les méthodes de conversion correspondantes lèvent une InvalidCastException exception :

Toutes les conversions de nombres intégraux ou à virgule flottante en valeurs booléennes convertissent des valeurs non nulles pour true et des valeurs zéro pour false. L’exemple suivant illustre ce comportement en appelant les surcharges sélectionnés de la Convert.ToBoolean classe.

using System;

public class Example
{
   public static void Main()
   {
      Byte byteValue = 12;
      Console.WriteLine(Convert.ToBoolean(byteValue));
      Byte byteValue2 = 0;
      Console.WriteLine(Convert.ToBoolean(byteValue2));
      int intValue = -16345;
      Console.WriteLine(Convert.ToBoolean(intValue));
      long longValue = 945;
      Console.WriteLine(Convert.ToBoolean(longValue));
      SByte sbyteValue = -12;
      Console.WriteLine(Convert.ToBoolean(sbyteValue));
      double dblValue = 0;
      Console.WriteLine(Convert.ToBoolean(dblValue));
      float sngValue = .0001f;
      Console.WriteLine(Convert.ToBoolean(sngValue));
   }
}
// The example displays the following output:
//       True
//       False
//       True
//       True
//       True
//       False
//       True

Lors de la conversion de valeurs à virgule flottante en valeurs booléennes, les méthodes de conversion effectuent une comparaison exacte à zéro. Si la valeur à virgule flottante a perdu la précision, le résultat peut être inattendu. Ceci est illustré dans l’exemple suivant, dans lequel un Double variable dont la valeur doit être égal à zéro est convertie en valeur booléenne. Comme le montre l’exemple, le résultat est true étant donné que les ajouts de 0,2 ont abouti à une perte de précision.

Lors de la conversion à partir de la valeur booléenne en valeurs numériques, les méthodes de conversion de la Convert classe convert true 1 et false à 0. Toutefois, les fonctions de conversion de Visual Basic convertissent true soit 255 (pour les conversions Byte valeurs) ou -1 (pour toutes les autres conversions numériques). L’exemple suivant convertit true en valeurs numériques à l’aide un Convert (méthode) et, dans le cas de l’exemple Visual Basic, à l’aide de l’opérateur de conversion de Visual Basic de langage propres.

using System;

public class Example
{
   public static void Main()
   {
      bool flag = true;

      byte byteValue;   
      byteValue = Convert.ToByte(flag);
      Console.WriteLine("{0} -> {1}", flag, byteValue);         

      sbyte sbyteValue;
      sbyteValue = Convert.ToSByte(flag);
      Console.WriteLine("{0} -> {1}", flag, sbyteValue);         

      double dblValue;
      dblValue = Convert.ToDouble(flag);
      Console.WriteLine("{0} -> {1}", flag, dblValue);         

      int intValue;
      intValue = Convert.ToInt32(flag);
      Console.WriteLine("{0} -> {1}", flag, intValue);         
   }
}
// The example displays the following output:
//       True -> 1
//       True -> 1
//       True -> 1
//       True -> 1

Pour les conversions entre Boolean pour les valeurs de chaîne, consultez la mise en forme des valeurs booléennes section. Pour les conversions de chaînes à Boolean valeurs, consultez le l’analyse des valeurs booléennes section.

Le Boolean structure inclut deux méthodes d’analyse statiques, Parse et TryParse, qui convertir une chaîne en valeur booléenne. La représentation sous forme de chaîne d’une valeur booléenne est définie par les équivalents pas la casse des valeurs de la TrueString et FalseString des champs, qui sont « True » et « False », respectivement. En d’autres termes, que des chaînes qui procèdent sont « True », « False », « true », « false » ou certaines équivalent à casse mixte. Vous ne pouvez pas analyser correctement les chaînes numériques telles que « 0 » ou « 1 ». Les espaces blancs ou de fin ne sont pas considérés lors de l’exécution de la comparaison de chaînes.

L’exemple suivant utilise le Parse et TryParse des méthodes pour analyser un nombre de chaînes. Notez que seuls les équivalents pas la casse de « True » et « False » peuvent être analysés avec succès.

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { null, String.Empty, "True", "False", 
                          "true", "false", "    true    ", 
                           "TrUe", "fAlSe", "fa lse", "0",  
                          "1", "-1", "string" };
      // Parse strings using the Boolean.Parse method.                    
      foreach (var value in values) {
         try {
            bool flag = Boolean.Parse(value);
            Console.WriteLine("'{0}' --> {1}", value, flag);
         }
         catch (ArgumentException) {
            Console.WriteLine("Cannot parse a null string.");
         }   
         catch (FormatException) {
            Console.WriteLine("Cannot parse '{0}'.", value);
         }         
      }
      Console.WriteLine();
      // Parse strings using the Boolean.TryParse method.                    
      foreach (var value in values) {
         bool flag = false;
         if (Boolean.TryParse(value, out flag))
            Console.WriteLine("'{0}' --> {1}", value, flag);
         else
            Console.WriteLine("Unable to parse '{0}'", value);
      }                                     
   }
}
// The example displays the following output:
//       Cannot parse a null string.
//       Cannot parse ''.
//       'True' --> True
//       'False' --> False
//       'true' --> True
//       'false' --> False
//       '    true    ' --> True
//       'TrUe' --> True
//       'fAlSe' --> False
//       Cannot parse 'fa lse'.
//       Cannot parse '0'.
//       Cannot parse '1'.
//       Cannot parse '-1'.
//       Cannot parse 'string'.
//       
//       Unable to parse ''
//       Unable to parse ''
//       'True' --> True
//       'False' --> False
//       'true' --> True
//       'false' --> False
//       '    true    ' --> True
//       'TrUe' --> True
//       'fAlSe' --> False
//       Cannot parse 'fa lse'.
//       Unable to parse '0'
//       Unable to parse '1'
//       Unable to parse '-1'
//       Unable to parse 'string'

Si vous programmez en Visual Basic, vous pouvez utiliser la CBool fonction pour convertir la représentation sous forme de chaîne d’un nombre en valeur booléenne. « 0 » est convertie en false, et la représentation sous forme de chaîne d’une valeur différente de zéro est convertie en true. Si vous programmez pas en Visual Basic, vous devez convertir votre chaîne numérique à un nombre avant de le convertir en une valeur booléenne. L’exemple suivant illustre ce comportement en convertissant un tableau d’entiers en valeurs booléennes.

using System;

public class Example
{
   public static void Main()
   {
      String[] values = { "09", "12.6", "0", "-13 " };
      foreach (var value in values) {
         bool success, result;
         int number; 
         success = Int32.TryParse(value, out number);
         if (success) {
            // The method throws no exceptions.
            result = Convert.ToBoolean(number);
            Console.WriteLine("Converted '{0}' to {1}", value, result);
         }
         else {
            Console.WriteLine("Unable to convert '{0}'", value); 
         }         
      }
   }
}
// The example displays the following output:
//       Converted '09' to True
//       Unable to convert '12.6'
//       Converted '0' to False
//       Converted '-13 ' to True

Étant donné que les valeurs booléennes sont true ou false, il est recommandé d’appeler explicitement la CompareTo (méthode), qui indique si une instance est supérieure à, inférieur à, ou égal à une valeur spécifiée. En règle générale, pour comparer deux variables booléennes, appelez le Equals méthode ou utiliser l’opérateur d’égalité de votre langage.

Toutefois, lorsque vous souhaitez comparer une variable booléenne avec la valeur booléenne littérale true ou false, il n’est pas nécessaire effectuer une comparaison explicite, car le résultat de l’évaluation d’une valeur booléenne est cette valeur booléenne. Par exemple, les expressions

if (booleanValue) {

And

using System;

public class Example
{
   public static void Main()
   {
      bool[] hasServiceCharges = { true, false };
      Decimal subtotal = 120.62m;
      Decimal shippingCharge = 2.50m;
      Decimal serviceCharge = 5.00m;

      foreach (var hasServiceCharge in hasServiceCharges) {
         Decimal total = subtotal + shippingCharge + 
                                (hasServiceCharge ? serviceCharge : 0);
         Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.", 
                           total, hasServiceCharge);                       
      }
   }
}
// The example displays output like the following:
//       hasServiceCharge = True: The total is $128.12.
//       hasServiceCharge = False: The total is $123.12.

sont équivalents, mais le deuxième est le plus compact. Toutefois, ces deux techniques offrent des performances comparables.

Valeur booléenne occupe un octet de la mémoire, comme le montre l’exemple c# suivant. L’exemple doit être compilé avec le /unsafe basculer.

using System;

public struct BoolStruct
{
   public bool flag1;
   public bool flag2;
   public bool flag3;
   public bool flag4;
   public bool flag5;
}

public class Example
{
   public static void Main()
   {
      unsafe {
         BoolStruct b = new BoolStruct();
         bool* addr = (bool*) &b;
         Console.WriteLine("Size of BoolStruct: {0}", sizeof(BoolStruct));
         Console.WriteLine("Field offsets:");
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag1 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag2 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag3 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag4 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag5 - addr);
      }
   }
}
// The example displays the following output:
//       Size of BoolStruct: 5
//       Field offsets:
//          flag1: 0
//          flag1: 1
//          flag1: 2
//          flag1: 3
//          flag1: 4

Bit de poids faible de l’octet est utilisé pour représenter la valeur. La valeur 1 représente true; la valeur 0 représente false.

System_CAPS_warningAvertissement

Vous pouvez utiliser la System.Collections.Specialized.BitVector32 structure pour travailler avec des ensembles de valeurs booléennes.

Vous pouvez convertir une valeur booléenne en sa représentation sous forme binaire en appelant le BitConverter.GetBytes(Boolean) (méthode). La méthode retourne un tableau d’octets avec un seul élément. Pour restaurer une valeur booléenne à partir de sa représentation sous forme binaire, vous pouvez appeler la BitConverter.ToBoolean(Byte[], Int32) (méthode).

L’exemple suivant appelle la BitConverter.GetBytes méthode pour convertir une valeur booléenne à sa représentation binaire et les affiche les bits individuels de la valeur et appelle ensuite la BitConverter.ToBoolean méthode pour restaurer la valeur à partir de sa représentation sous forme binaire.

using System;

public class Example
{
   public static void Main()
   {
      bool[] flags = { true, false };
      foreach (var flag in flags) {
         // Get binary representation of flag.
         Byte value = BitConverter.GetBytes(flag)[0];
         Console.WriteLine("Original value: {0}", flag);
         Console.WriteLine("Binary value:   {0} ({1})", value, 
                           GetBinaryString(value));
         // Restore the flag from its binary representation.
         bool newFlag = BitConverter.ToBoolean( new Byte[] { value }, 0);
         Console.WriteLine("Restored value: {0}\n", flag);
      }
   }

   private static string GetBinaryString(Byte value)
   {
      String retVal = Convert.ToString(value, 2);
      return new String('0', 8 - retVal.Length) + retVal;
   }
}
// The example displays the following output:
//       Original value: True
//       Binary value:   1 (00000001)
//       Restored value: True
//       
//       Original value: False
//       Binary value:   0 (00000000)
//       Restored value: False

Cette section illustre les valeurs booléennes comment sont utilisées dans les applications. La première section explique son utilisation comme un indicateur. Le second illustre son utilisation pour les opérations arithmétiques.

Variables booléennes sont généralement utilisés comme indicateurs, pour signaler la présence ou l’absence d’une condition. Par exemple, dans le String.Compare(String, String, Boolean) (méthode), le dernier paramètre, ignoreCase, est un indicateur qui indique si la comparaison de deux chaînes respecte la casse (ignoreCase est true) ou respectant la casse (ignoreCase est false). La valeur de l’indicateur peut être évaluée dans une instruction conditionnelle.

L’exemple suivant utilise une application console simple pour illustrer l’utilisation de variables booléennes en tant qu’indicateurs. L’application accepte les paramètres de ligne de commande qui permettent de sortie à être redirigées vers un fichier spécifié (le /f basculer), et qui permettent à envoyer à la fois dans un fichier spécifié et à la console de sortie (la /b basculer). L’application définit un indicateur nommé isRedirected pour indiquer si la sortie doit être envoyée vers un fichier, et un indicateur nommé isBoth pour indiquer que la sortie doit être envoyée à la console.

using System;
using System.IO;
using System.Threading;

public class Example
{
   public static void Main()
   {
      // Initialize flag variables.
      bool isRedirected = false;
      bool isBoth = false; 
      String fileName = "";
      StreamWriter sw = null;

      // Get any command line arguments.
      String[] args = Environment.GetCommandLineArgs();
      // Handle any arguments.
      if (args.Length > 1) { 
         for (int ctr = 1; ctr < args.Length; ctr++) {
            String arg = args[ctr];
            if (arg.StartsWith("/") || arg.StartsWith("-")) {
               switch (arg.Substring(1).ToLower())
               {
                  case "f":
                     isRedirected = true;
                     if (args.Length < ctr + 2) {
                        ShowSyntax("The /f switch must be followed by a filename.");
                        return;
                     }
                     fileName = args[ctr + 1];
                     ctr++;
                     break;
                  case "b":
                     isBoth = true;
                     break;
                  default:
                     ShowSyntax(String.Format("The {0} switch is not supported", 
                                              args[ctr]));
                     return;
               }
            }   
         }
      }

      // If isBoth is True, isRedirected must be True.
      if (isBoth &&  ! isRedirected) { 
         ShowSyntax("The /f switch must be used if /b is used.");
         return;
      }

      // Handle output.
      if (isRedirected) {
         sw = new StreamWriter(fileName); 
         if (!isBoth)
            Console.SetOut(sw); 
      }     
      String msg = String.Format("Application began at {0}", DateTime.Now);
      Console.WriteLine(msg);
      if (isBoth) sw.WriteLine(msg);
      Thread.Sleep(5000);
      msg = String.Format("Application ended normally at {0}", DateTime.Now);
      Console.WriteLine(msg);
      if (isBoth) sw.WriteLine(msg);
      if (isRedirected) sw.Close();
   }

   private static void ShowSyntax(String errMsg)
   {
      Console.WriteLine(errMsg);
      Console.WriteLine("\nSyntax: Example [[/f <filename> [/b]]\n");
   }
}

Une valeur booléenne est parfois utilisée pour indiquer la présence d’une condition qui déclenche un calcul mathématique. Par exemple, un hasShippingCharge variable peut servir d’un indicateur pour indiquer si vous souhaitez ajouter des frais d’expédition d’une facture.

Car une opération avec un false valeur n’a aucun effet sur le résultat d’une opération, il n’est pas nécessaire de convertir la valeur booléenne à une valeur entière à utiliser dans l’opération mathématique. Au lieu de cela, vous pouvez utiliser la logique conditionnelle.

L’exemple suivant calcule un montant qui se compose d’un sous-total, des frais d’expédition et une charge de service facultatif. Le hasServiceCharge variable détermine si les frais de service est appliquée. Au lieu de la conversion hasServiceCharge à une valeur numérique et en le multipliant par le montant des frais de service, l’exemple utilise une logique conditionnelle pour ajouter le montant des frais de service s’il n’est applicable.

using System;

public class Example
{
   public static void Main()
   {
      bool[] hasServiceCharges = { true, false };
      Decimal subtotal = 120.62m;
      Decimal shippingCharge = 2.50m;
      Decimal serviceCharge = 5.00m;

      foreach (var hasServiceCharge in hasServiceCharges) {
         Decimal total = subtotal + shippingCharge + 
                                (hasServiceCharge ? serviceCharge : 0);
         Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.", 
                           total, hasServiceCharge);                       
      }
   }
}
// The example displays output like the following:
//       hasServiceCharge = True: The total is $128.12.
//       hasServiceCharge = False: The total is $123.12.

Pendant le marshaling des types de données de base à COM est généralement simple, le Boolean type de données est une exception. Vous pouvez appliquer la MarshalAsAttribute attribut pour marshaler les Boolean type à la représentation suivante :

Type d'énumération

Format non managé

UnmanagedType.Bool

Une valeur d’entier de 4 octets, où toute valeur différente de zéro représente true et 0 représente false. C’est le format par défaut d’un Boolean champ dans une structure et d’un Boolean paramètre dans la plateforme appeler les appels.

UnmanagedType.U1

Une valeur d’entier de 1 octet, où le 1 représente true et 0 représente false.

UnmanagedType.VariantBool

Une valeur d’entier de 2 octets, où -1 représente true et 0 représente false. Il s’agit du format par défaut d’un Boolean paramètre dans les appels COM interop.

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1

Tous les membres de ce type sont thread-safe. Les membres qui semblent modifier l’état de l’instance retournent en fait une nouvelle instance initialisée avec la nouvelle valeur. Comme avec tout autre type, la lecture et en écriture à une variable partagée qui contient une instance de ce type doivent être protégées par un verrou pour garantir la sécurité des threads.

Retour au début
Afficher: