Informations
Le sujet que vous avez demandé est indiqué ci-dessous. Toutefois, ce sujet ne figure pas dans la bibliothèque.

Boolean, structure

Représentetrue (ou) falseune valeur booléenne.

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

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

Le type Boolean expose les membres suivants.

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCompareTo(Boolean)Compare cette instance à un objet Boolean spécifié et retourne un entier qui indique la relation entre ces deux éléments.
Méthode publiquePris en charge par XNA FrameworkCompareTo(Object)Compare cette instance à l'objet spécifié et retourne un entier qui indique la relation entre ces deux éléments.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Boolean)Retourne une valeur indiquant si cette instance équivaut à un objet Boolean spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Object)Renvoie une valeur indiquant si cette instance équivaut à un objet spécifié. (Substitue ValueType.Equals(Object).)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetHashCodeRetourne le code de hachage de cette instance. (Substitue ValueType.GetHashCode().)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkGetTypeCodeRetourne le TypeCode du type valeur Boolean.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreParseConvertit la représentation sous forme de chaîne spécifiée d'une valeur logique en son Boolean équivalent, ou lève une exception si la chaîne n'est pas égale à la valeur de Boolean.TrueString ou Boolean.FalseString.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString()Convertit la valeur de cette instance en sa représentation sous forme de chaîne équivalente ("True" ou "False"). (Substitue ValueType.ToString().)
Méthode publiquePris en charge par XNA FrameworkToString(IFormatProvider)Convertit la valeur de cette instance en sa représentation sous forme de chaîne équivalente ("True" ou "False").
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTryParseTente de convertir la représentation sous forme de chaîne d'une valeur logique en son équivalent Boolean. Une valeur de retour indique si la conversion a réussi ou a échoué.
Début

  NomDescription
Champ publicMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFalseStringReprésente la valeur booléenne false sous forme de chaîne. Ce champ est en lecture seule.
Champ publicMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTrueStringReprésente la valeur booléenne true sous forme de chaîne. Ce champ est en lecture seule.
Début

  NomDescription
Implémentation d'interface expliciteMéthode privéePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIComparable.CompareToInfrastructure. Compare l'instance actuelle avec un autre objet du même type et retourne un entier qui indique si l'instance actuelle précède ou suit un autre objet ou se trouve à la même position dans l'ordre de tri.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToBooleanInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToBoolean.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToByteInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToByte.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToCharInfrastructure. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève un InvalidCastException.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDateTimeInfrastructure. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève un InvalidCastException.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDecimalInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToDecimal.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDoubleInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToDouble.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt16Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToInt16.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt32Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToInt32.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt64Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToInt64.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToSByteInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToSByte.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToSingleInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToSingle.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToTypeInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToType.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt16Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt16.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt32Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt32.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt64Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt64.
Début

Une instance d'Boolean peut avoir l'une des deux valeurs suivantes : true, ou false.

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

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

  • Chaînes d'analyse pour les convertir en valeurs booléennes : Parse et TryParse

  • Comparaison des valeurs suivantes : CompareTo et Equals

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

Valeurs booléennes de mise en forme
Conversion vers et depuis des valeurs booléennes
Valeurs booléennes d'analyse
Comparer des valeurs booléennes
Utilisation des booléens comme valeurs binaires
Exécution d'opérations avec des valeurs booléennes

Valeurs booléennes de mise en forme

La représentation de chaîne d'Boolean est « true » pour une valeur ou « False » pour true pour valeur de false. La représentation de chaîne de valeur de Boolean est définie par TrueString et les champs en lecture seule d'FalseString.

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

L'exemple suivant montre la mise en forme avec la méthode pour ToString. Notez que l'exemple utilise la fonctionnalité d'mise en forme composite, la méthode de ToString 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


Comme la structure d'Boolean peut avoir deux valeurs, il est facile d'ajouter la mise en forme personnalisée. Pour la mise en forme personnalisée simple dans laquelle les littéraux de chaîne sont substitués « true » et « False », vous pouvez utiliser n'importe quelle fonctionnalité conditionnelle d'évaluation prise en charge par le langage, par exemple opérateur conditionnel en c ou Si opérateur en Visual Basic. L'exemple suivant utilise cette technique pour mettre en forme des valeurs d'Boolean comme « yes » et « no » au lieu de « 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 complexes de format personnalisée, notamment la mise en forme dépend de la culture, vous pouvez appeler la méthode d'String.Format(IFormatProvider, String, Object[]) et fournir une implémentation d'ICustomFormatter. L'exemple suivant implémente les interfaces d'ICustomFormatter et d'IFormatProvider pour fournir des chaînes booléennes dépendantes de la culture pour les cultures anglais (états-unis), de en français (France), et russes (la 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': верно


Éventuellement, vous pouvez utiliser fichiers de ressources pour définir les chaînes booléennes spécifiques à une culture.

Conversion vers et depuis des valeurs booléennes

La structure d'Boolean implémente l'interface d'IConvertible. Par conséquent, vous pouvez utiliser la classe d'Convert pour effectuer des conversions entre une valeur d'Boolean et tout autre type de primitive du .NET Framework, ou vous pouvez appeler les implémentations explicites de la structure d'Boolean. Toutefois, les conversions entre Boolean et les types ne sont pas prises en charge, les méthodes de conversion correspondantes lèvent une exception d'InvalidCastException :

Toutes les conversions en intégrale ou de nombres à virgule flottante aux valeurs booléennes convertissent les valeurs différentes de zéro à true et des valeurs zéro à false. L'exemple suivant illustre cela en appelant les surcharges sélectionnées de la classe d'Convert.ToBoolean.


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 aux valeurs booléennes, les méthodes de conversion exécutent une comparaison exacte avec zéro. Si la valeur à virgule flottante a perdu la précision, le résultat peut être inattendue. Cela est illustré dans l'exemple suivant, dans lequel une variable d'Double dont la valeur doit être zéro est convertie en valeur booléenne. Lorsque l'exemple montre, le résultat est true car les ajouts répétés de 0,2 ont provoqué une perte de précision.

Lors de la conversion de valeurs booléennes aux valeurs numériques, les méthodes de conversion de la classe d'Convert convertissent true à 1 et false à 0. Toutefois, les fonctions de conversion Visual Basic convertissent true et 255 (pour les conversions aux valeurs d'Byte ) ou -1 (pour toutes les conversions numériques). L'exemple suivant convertit true des valeurs numériques en utilisant une méthode d'Convert, puis, dans le cas de l'exemple Visual Basic, à l'aide de son opérateur de conversion du langage Visual Basic.


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 d'Boolean aux valeurs de chaîne, consultez la section " Valeurs booléennes de mise en forme. Pour les conversions de chaînes en valeurs d'Boolean, consultez la section " Valeurs booléennes d'analyse.

Valeurs booléennes d'analyse

La structure d'Boolean inclut deux méthodes, Parse et TryParsestatiques d'analyse, qui convertissent une chaîne en valeur booléenne. La représentation de chaîne d'une valeur booléenne est définie par les équivalents sensibles à la casse des valeurs des champs d'TrueString et d'FalseString, qui sont « true » et « False », respectivement. En d'autres termes, seules les chaînes qui procèdent sont « true », « False », « true », « false », ou certains équivalent de mixte CASE. Vous ne pouvez pas pu analyser les chaînes numériques tels que « 0 " ou « 1 ". Les espaces blancs à gauche ou à droite ne sont pas considérés lors de la comparaison de chaînes.

L'exemple suivant utilise des méthodes d'Parse et d'TryParse pour analyser plusieurs chaînes. Notez que seuls les équivalents sensibles à la casse « true » et « False » peuvent être correctement analysé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 fonction d'CBool pour convertir la représentation de chaîne d'un nombre à une valeur booléenne. « 0 " est converti en false, et la représentation de chaîne de toute valeur autre que zéro est convertie en true. Si vous programmez ne pas en Visual Basic, vous devez convertir la chaîne numérique en un nombre avant de les convertir en une valeur booléenne. L'exemple suivant illustre cela en convertissant un tableau d'entiers aux 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


Comparer des valeurs booléennes

Les valeurs booléennes sont true ou false, il y a peu de raison d'appeler explicitement la méthode d'CompareTo, qui indique si une instance est supérieur à, inférieur à, ou égale à une valeur spécifiée. En général, pour comparer deux variables booléennes, vous devez appeler la méthode de Equals ou utiliser l'opérateur d'égalité de votre langage.

Toutefois, lorsque vous souhaitez comparer une variable booléenne contenant la valeur booléenne true littérale ou false, il n'est pas nécessaire d'effectuer une comparaison explicite, car le résultat de l'évaluation valeur booléenne est la 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 équivalent, mais le second est plus compact. Toutefois, les deux techniques suivantes offrent des performances comparables.

Utilisation des booléens comme valeurs binaires

Valeur booléenne occupe un octet de mémoire. Le bit d'bas de l'octet est utilisé pour représenter la valeur. La valeur 1 représente true; la valeur 0 représente false.

Mise en gardeAttention

Vous pouvez utiliser la structure d'System.Collections.Specialized.BitVector32 pour utiliser des jeux de valeurs booléennes.

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

L'exemple suivant appelle la méthode de BitConverter.GetBytes pour convertir une valeur booléenne en sa représentation binaire et affiche différents bits de la valeur, puis appelle la méthode de BitConverter.ToBoolean pour restaurer la valeur de sa représentation 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


Exécution d'opérations avec des valeurs booléennes

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

a28wyd50.collapse_all(fr-fr,VS.110).gifValeurs booléennes comme indicateurs

Les variables booléennes sont les plus couramment utilisées comme indicateurs, pour indiquer la présence ou l'absence d'une certaine condition. Par exemple, dans la méthode d'String.Compare(String, String, Boolean), la valeur finale, ignoreCase, est un indicateur qui indique si la comparaison de deux chaînes respecte la casse respect de la casse (ignoreCase est true) ou (ignoreCase est false). La valeur de l'indicateur peut être évaluée dans une instruction conditionnelle.

L'exemple suivant utilise une application console simple de pour illustrer l'utilisation des variables booléennes comme indicateurs. L'application reçoit les paramètres de ligne de commande qui permettent la sortie à rediriger vers un fichier spécifié (le sélecteur d'/f ), et qui activent la sortie à envoyer à un fichier spécifié et à la console (le sélecteur d'/b ). L'application définit une balise nommée isRedirected pour indiquer si la sortie doit être envoyée à un fichier, et une balise nommée 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");
   }
}


a28wyd50.collapse_all(fr-fr,VS.110).gifValeur booléenne et opérations arithmétiques

Valeur booléenne est parfois utilisée pour indiquer la présence d'une condition qui génère un calcul mathématique. Par exemple, une variable d'hasShippingCharge peut servir d'indicateur pour indiquer s'il faut ajouter des frais de transport à une valeur de facture.

Étant donné qu'une opération avec une valeur d'false n'a aucun effet sur le résultat d'une opération, il n'est pas nécessaire de convertir la valeur booléenne en une valeur intégrale à utiliser lors de l'opération mathématique. À la place, vous pouvez utiliser la logique conditionnelle.

L'exemple suivant calcule une valeur qui se compose d'un sous-total, les frais de transport, et les coûts administratifs facultatifs. La variable d'hasServiceCharge détermine si les coûts administratifs sont appliqués. Au lieu de convertir hasServiceCharge une valeur numérique et de la multiplier par la quantité les coûts administratifs, la logique conditionnelle d'exemple utilise pour ajouter le montant de frais d'administration le cas échéant.


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.


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres de ce type sont thread-safe. Les membres qui semblent modifier l'instance d'état retournent, en réalité, une nouvelle instance initialisée avec la nouvelle valeur. Comme avec tout autre type, la lecture et l'écriture sur une variable partagée qui contient une instance de ce type doivent être protégées par un verrou pour garantir la cohérence de thread.

Ajouts de la communauté

Afficher:
© 2014 Microsoft