Boolean Boolean Boolean Boolean Struct

Définition

Représente une valeur booléenne (true ou false).Represents a Boolean (true or false) value.

public value class Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
type bool = struct
    interface IConvertible
Public Structure Boolean
Implements IComparable, IComparable(Of Boolean), IConvertible, IEquatable(Of Boolean)
Héritage
Attributs
Implémente

Remarques

Une Boolean instance peut avoir l’une des deux valeurs truesuivantes : false, ou.A Boolean instance can have either of two values: true, or false.

La Boolean structure fournit des méthodes qui prennent en charge les tâches suivantes :The Boolean structure provides methods that support the following tasks:

Les sections suivantes expliquent ces tâches et d’autres informations sur l’utilisation :The following sections explain these tasks and other usage details:

Mise en forme des valeurs booléennes Formatting Boolean values
Conversion vers et à partir de valeurs booléennes Converting to and from Boolean values
Analyse des valeurs booléennes Parsing Boolean values
Comparaison de valeurs booléennes Comparing Boolean values
Utilisation de valeurs booléennes comme valeurs binaires Working with Booleans as binary values
Exécution d’opérations avec des valeurs booléennes Performing operations with Boolean values
Valeurs booléennes et InteropBooleans and Interop

Mise en forme des valeurs booléennesFormatting Boolean values

La représentation sous forme de Boolean chaîne d’un est soit « true true » pour une valeur, soit « false false » pour une valeur.The string representation of a Boolean is either "True" for a true value or "False" for a false value. La représentation sous forme de Boolean chaîne d’une valeur est définie par les TrueString champs FalseString en lecture seule et.The string representation of a Boolean value is defined by the read-only TrueString and FalseString fields.

Vous utilisez la ToString méthode pour convertir des valeurs booléennes en chaînes.You use the ToString method to convert Boolean values to strings. La structure booléenne comprend deux ToString surcharges : la ToString() méthode sans paramètre et la ToString(IFormatProvider) méthode, qui comprend un paramètre qui contrôle la mise en forme.The Boolean structure includes two ToString overloads: the parameterless ToString() method and the ToString(IFormatProvider) method, which includes a parameter that controls formatting. Toutefois, étant donné que ce paramètre est ignoré, les deux surcharges produisent des chaînes identiques.However, because this parameter is ignored, the two overloads produce identical strings. La ToString(IFormatProvider) méthode ne prend pas en charge la mise en forme dépendante de la culture.The ToString(IFormatProvider) method does not support culture-sensitive formatting.

L’exemple suivant illustre la mise en forme avec ToString la méthode.The following example illustrates formatting with the ToString method. Notez que l’exemple utilise la fonctionnalité de mise en forme composite , de sorte que la ToString méthode est appelée implicitement.Note that the example uses the composite formatting feature, so the ToString method is called implicitly.

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
Module Example
   Public Sub Main()
      Dim raining As Boolean = False
      Dim busLate As Boolean = True

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

Étant donné Boolean que la structure ne peut avoir que deux valeurs, il est facile d’ajouter une mise en forme personnalisée.Because the Boolean structure can have only two values, it is easy to add custom formatting. Pour une mise en forme personnalisée simple dans laquelle d’autres littéraux de chaîne remplacent « true » et « false », vous pouvez utiliser toute fonctionnalité d’évaluation conditionnelle prise en charge par votre langage, C# telle que l' opérateur conditionnel dans ou l' opérateur If dans Visual Basic.For simple custom formatting in which other string literals are substituted for "True" and "False", you can use any conditional evaluation feature supported by your language, such as the conditional operator in C# or the If operator in Visual Basic. L’exemple suivant utilise cette technique pour mettre Boolean en forme les valeurs comme « Yes » et « no » plutôt que « true » et « false ».The following example uses this technique to format Boolean values as "Yes" and "No" rather than "True" and "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
Module Example
   Public Sub Main()
      Dim raining As Boolean = False
      Dim busLate As Boolean = True

      Console.WriteLine("It is raining: {0}", 
                        If(raining, "Yes", "No"))
      Console.WriteLine("The bus is late: {0}", 
                        If(busLate, "Yes", "No"))
   End Sub
End Module
' 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 ICustomFormatter culture, vous pouvez appeler la String.Format(IFormatProvider, String, Object[]) méthode et fournir une implémentation.For more complex custom formatting operations, including culture-sensitive formatting, you can call the String.Format(IFormatProvider, String, Object[]) method and provide an ICustomFormatter implementation. L’exemple suivant implémente les ICustomFormatter interfaces IFormatProvider et pour fournir des chaînes booléennes dépendantes de la culture pour les cultures anglais (États-Unis), français (France) et russe (Russie).The following example implements the ICustomFormatter and IFormatProvider interfaces to provide culture-sensitive Boolean strings for the English (United States), French (France), and Russian (Russia) cultures.

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': верно
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "", "en-US", "fr-FR", "ru-RU" }
      For Each cultureName In cultureNames
         Dim value As Boolean = True
         Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
         Dim formatter As New BooleanFormatter(culture)
         
         Dim result As String = String.Format(formatter, "Value for '{0}': {1}", culture.Name, value)
         Console.WriteLine(result)
      Next
   End Sub
End Module

Public Class BooleanFormatter 
   Implements ICustomFormatter, IFormatProvider
   
   Private culture As CultureInfo
   
   Public Sub New()
      Me.New(CultureInfo.CurrentCulture)
   End Sub
   
   Public Sub New(culture As CultureInfo)
      Me.culture = culture 
   End Sub
   
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If                
   End Function
   
   Public Function Format(fmt As String, arg As Object, 
                          formatProvider As IFormatProvider) As String _
                   Implements ICustomFormatter.Format
      ' Exit if another format provider is used.
      If Not formatProvider.Equals(Me) Then Return Nothing
      
      ' Exit if the type to be formatted is not a Boolean
      If Not TypeOf arg Is Boolean Then Return Nothing
      
      Dim value As Boolean = CBool(arg)
      Select culture.Name
         Case "en-US"
            Return value.ToString()
         Case "fr-FR"
            If value Then
               Return "vrai"
            Else
               Return "faux"
            End If      
         Case "ru-RU"
            If value Then
               Return "верно"
            Else
               Return "неверно"
            End If   
         Case Else
            Return value.ToString()  
      End Select
   End Function
End Class
' 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 des fichiers de ressources pour définir des chaînes booléennes spécifiques à la culture.Optionally, you can use resource files to define culture-specific Boolean strings.

Conversion vers et à partir de valeurs booléennesConverting to and from Boolean values

La Boolean structure implémente l' IConvertible interface.The Boolean structure implements the IConvertible interface. Par conséquent, vous pouvez utiliser la Convert classe pour effectuer des conversions entre une Boolean valeur et tout autre type primitif dans le .NET Framework, ou vous pouvez appeler les Boolean implémentations explicites de la structure.As a result, you can use the Convert class to perform conversions between a Boolean value and any other primitive type in the .NET Framework, or you can call the Boolean structure's explicit implementations. Toutefois, les conversions entre Boolean un et les types suivants ne sont pas prises en charge, donc les méthodes InvalidCastException de conversion correspondantes lèvent une exception :However, conversions between a Boolean and the following types are not supported, so the corresponding conversion methods throw an InvalidCastException exception:

Toutes les conversions de nombres intégraux ou à virgule flottante en valeurs booléennes convertissent true des valeurs non null falseen valeurs et nulles en.All conversions from integral or floating-point numbers to Boolean values convert non-zero values to true and zero values to false. L’exemple suivant illustre cela en appelant les surcharges sélectionnées de la Convert.ToBoolean classe.The following example illustrates this by calling selected overloads of the Convert.ToBoolean class.

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
Module Example
   Public Sub Main()
      Dim byteValue As Byte = 12
      Console.WriteLine(Convert.ToBoolean(byteValue))
      Dim byteValue2 As Byte = 0
      Console.WriteLine(Convert.ToBoolean(byteValue2))
      Dim intValue As Integer = -16345
      Console.WriteLine(Convert.ToBoolean(intValue))
      Dim longValue As Long = 945
      Console.WriteLine(Convert.ToBoolean(longValue))
      Dim sbyteValue As SByte = -12
      Console.WriteLine(Convert.ToBoolean(sbyteValue))
      Dim dblValue As Double = 0
      Console.WriteLine(Convert.ToBoolean(dblValue))
      Dim sngValue As Single = .0001
      Console.WriteLine(Convert.ToBoolean(sngValue))
   End Sub
End Module
' 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 avec zéro.When converting from floating-point values to Boolean values, the conversion methods perform an exact comparison with zero. Si la valeur à virgule flottante a perdu la précision, le résultat peut être inattendu.If the floating-point value has lost precision, the result can be unexpected. Cela est illustré dans l’exemple suivant, dans lequel une Double variable dont la valeur doit être égale à zéro est convertie en valeur booléenne.This is illustrated in the following example, in which a Double variable whose value should be zero is converted to a Boolean value. Comme le montre l’exemple, le résultat true est que les ajouts répétés de 0,2 ont entraîné une perte de précision.As the example shows, the result is true because repeated additions of 0.2 have resulted in a loss of precision.

Lors de la conversion de valeurs booléennes en valeurs numériques, les Convert méthodes de true conversion de la false classe convertissent en 1 et en 0.When converting from Boolean to numeric values, the conversion methods of the Convert class convert true to 1 and false to 0. Toutefois, les fonctions de conversion true Visual Basic sont converties en 255 (pour Byte les conversions en valeurs) ou-1 (pour toutes les autres conversions numériques).However, Visual Basic conversion functions convert true to either 255 (for conversions to Byte values) or -1 (for all other numeric conversions). L’exemple suivant convertit true en valeurs numériques à l’aide d’une Convert méthode, et, dans le cas de l’exemple de Visual Basic, à l’aide de l’opérateur de conversion propre au langage Visual Basic.The following example converts true to numeric values by using a Convert method, and, in the case of the Visual Basic example, by using the Visual Basic language's own conversion operator.

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
Module Example
   Public Sub Main()
      Dim flag As Boolean = true
      
      Dim byteValue As Byte   
      byteValue = Convert.ToByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, byteValue, 
                                            byteValue.GetType().Name)         
      byteValue = CByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, byteValue, 
                                            byteValue.GetType().Name)         
      
      Dim sbyteValue As SByte
      sbyteValue = Convert.ToSByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue, 
                                            sbyteValue.GetType().Name)         
      sbyteValue = CSByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue, 
                                            sbyteValue.GetType().Name)         

      Dim dblValue As Double
      dblValue = Convert.ToDouble(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, dblValue, 
                                            dblValue.GetType().Name)         
      dblValue = CDbl(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, dblValue, 
                                            dblValue.GetType().Name)         

      Dim intValue As Integer
      intValue = Convert.ToInt32(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, intValue, 
                                            intValue.GetType().Name)         
      intValue = CInt(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, intValue, 
                                            intValue.GetType().Name)         
   End Sub
End Module
' The example displays the following output:
'       True -> 1 (Byte)
'       True -> 255 (Byte)
'       True -> 1 (SByte)
'       True -> -1 (SByte)
'       True -> 1 (Double)
'       True -> -1 (Double)
'       True -> 1 (Int32)
'       True -> -1 (Int32)

Pour les conversions Boolean de en valeurs de chaîne, consultez la section mise en forme des valeurs booléennes .For conversions from Boolean to string values, see the Formatting Boolean Values section. Pour les conversions de chaînes Boolean en valeurs, consultez la section analyse des valeurs booléennes .For conversions from strings to Boolean values, see the Parsing Boolean Values section.

Analyse des valeurs booléennesParsing Boolean values

La Boolean structure comprend deux méthodes d’analyse statiques Parse , TryParseet, qui convertissent une chaîne en valeur booléenne.The Boolean structure includes two static parsing methods, Parse and TryParse, that convert a string to a Boolean value. La représentation sous forme de chaîne d’une valeur booléenne est définie par les équivalents qui ne respectent pas la casse TrueString des FalseString valeurs des champs et, respectivement « true » et « false ».The string representation of a Boolean value is defined by the case-insensitive equivalents of the values of the TrueString and FalseString fields, which are "True" and "False", respectively. En d’autres termes, les seules chaînes analysées avec succès sont « true », « false », « true », « false » ou un équivalent à casse mixte.In other words, the only strings that parse successfully are "True", "False", "true", "false", or some mixed-case equivalent. Vous ne pouvez pas analyser correctement les chaînes numériques telles que « 0 » ou « 1 ».You cannot successfully parse numeric strings such as "0" or "1". Les espaces blancs de début ou de fin ne sont pas pris en compte lors de l’exécution de la comparaison de chaînes.Leading or trailing white-space characters are not considered when performing the string comparison.

L’exemple suivant utilise les Parse méthodes TryParse et pour analyser un certain nombre de chaînes.The following example uses the Parse and TryParse methods to parse a number of strings. Notez que seuls les équivalents ne respectant pas la casse de « true » et « false » peuvent être analysés avec succès.Note that only the case-insensitive equivalents of "True" and "False" can be successfully parsed.

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'
Module Example
   Public Sub Main()
      Dim values() As String = { Nothing, String.Empty, "True", "False", 
                                 "true", "false", "    true    ", 
                                 "TrUe", "fAlSe", "fa lse", "0", 
                                 "1", "-1", "string" }
      ' Parse strings using the Boolean.Parse method.                    
      For Each value In values
         Try
            Dim flag As Boolean = Boolean.Parse(value)
            Console.WriteLine("'{0}' --> {1}", value, flag)
         Catch e As ArgumentException
            Console.WriteLine("Cannot parse a null string.")
         Catch e As FormatException
            Console.WriteLine("Cannot parse '{0}'.", value)
         End Try         
      Next  
      Console.WriteLine()
      ' Parse strings using the Boolean.TryParse method.                    
      For Each value In values
         Dim flag As Boolean = False
         If Boolean.TryParse(value, flag)
            Console.WriteLine("'{0}' --> {1}", value, flag)
         Else
            Console.WriteLine("Cannot parse '{0}'.", value)
         End If         
      Next  
   End Sub
End Module
' 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 dans 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.If you are programming in Visual Basic, you can use the CBool function to convert the string representation of a number to a Boolean value. « 0 » est converti en falseet la représentation sous forme de chaîne de toute valeur différente de zéro est trueconvertie en."0" is converted to false, and the string representation of any non-zero value is converted to true. Si vous ne programmez pas dans Visual Basic, vous devez convertir votre chaîne numérique en nombre avant de la convertir en valeur booléenne.If you are not programming in Visual Basic, you must convert your numeric string to a number before converting it to a Boolean. L’exemple suivant illustre cela en convertissant un tableau d’entiers en valeurs booléennes.The following example illustrates this by converting an array of integers to Boolean values.

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
Module Example
   Public Sub Main()
      Dim values() As String = { "09", "12.6", "0", "-13 " }
      For Each value In values
         Dim success, result As Boolean
         Dim number As Integer 
         success = Int32.TryParse(value, number)
         If success Then
            ' 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)
         End If         
      Next
   End Sub
End Module
' The example displays the following output:
'       Converted '09' to True
'       Unable to convert '12.6'
'       Converted '0' to False
'       Converted '-13 ' to True

Comparaison de valeurs booléennesComparing Boolean values

Étant donné que les valeurs true booléennes sont ou false, il y a peu de CompareTo raison d’appeler explicitement la méthode, qui indique si une instance est supérieure, inférieure ou égale à une valeur spécifiée.Because Boolean values are either true or false, there is little reason to explicitly call the CompareTo method, which indicates whether an instance is greater than, less than, or equal to a specified value. En général, pour comparer deux variables booléennes, vous Equals appelez la méthode ou utilisez l’opérateur d’égalité de votre langage.Typically, to compare two Boolean variables, you call the Equals method or use your language's equality operator.

Toutefois, lorsque vous souhaitez comparer une variable booléenne avec la valeur true booléenne littérale ou false, il n’est pas nécessaire d’effectuer une comparaison explicite, car le résultat de l’évaluation d’une valeur booléenne est cette valeur booléenne.However, when you want to compare a Boolean variable with the literal Boolean value true or false, it is not necessary to do an explicit comparison, because the result of evaluating a Boolean value is that Boolean value. Par exemple, les expressionsFor example, the expressions

if (booleanValue) {
If booleanValue Then

etand

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.
Module Example
   Public Sub Main()
      Dim hasServiceCharges() As Boolean = { True, False }
      Dim subtotal As Decimal = 120.62d
      Dim shippingCharge As Decimal = 2.50d
      Dim serviceCharge As Decimal = 5.00d
      
      For Each hasServiceCharge In hasServiceCharges
         Dim total As Decimal = subtotal + shippingCharge + 
                                If(hasServiceCharge, serviceCharge, 0)
         Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.", 
                           total, hasServiceCharge)                       
      Next
   End Sub
End Module
' The example displays output like the following:
'       hasServiceCharge = True: The total is $128.12.
'       hasServiceCharge = False: The total is $123.12.

sont équivalents, mais la seconde est plus compacte.are equivalent, but the second is more compact. Toutefois, les deux techniques offrent des performances comparables.However, both techniques offer comparable performance.

Utilisation de valeurs booléennes comme valeurs binairesWorking with Booleans as binary values

Une valeur booléenne occupe un octet de mémoire, comme le montre C# l’exemple suivant.A Boolean value occupies one byte of memory, as the following C# example shows. L’exemple doit être compilé avec le /unsafe commutateur.The example must be compiled with the /unsafe switch.

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

Le bit de poids faible de l’octet est utilisé pour représenter sa valeur.The byte's low-order bit is used to represent its value. La valeur 1 représente true; une valeur de 0 représente. falseA value of 1 represents true; a value of 0 represents false.

Avertissement

Vous pouvez utiliser la System.Collections.Specialized.BitVector32 structure pour travailler avec des jeux de valeurs booléennes.You can use the System.Collections.Specialized.BitVector32 structure to work with sets of Boolean values.

Vous pouvez convertir une valeur booléenne en sa représentation binaire en appelant la BitConverter.GetBytes(Boolean) méthode.You can convert a Boolean value to its binary representation by calling the BitConverter.GetBytes(Boolean) method. La méthode retourne un tableau d’octets avec un seul élément.The method returns a byte array with a single element. Pour restaurer une valeur booléenne à partir de sa représentation binaire, vous pouvez BitConverter.ToBoolean(Byte[], Int32) appeler la méthode.To restore a Boolean value from its binary representation, you can call the BitConverter.ToBoolean(Byte[], Int32) method.

L’exemple suivant appelle la BitConverter.GetBytes méthode pour convertir une valeur booléenne en sa représentation binaire et affiche les bits individuels de la valeur, puis appelle la BitConverter.ToBoolean méthode pour restaurer la valeur à partir de sa représentation binaire.The following example calls the BitConverter.GetBytes method to convert a Boolean value to its binary representation and displays the individual bits of the value, and then calls the BitConverter.ToBoolean method to restore the value from its binary representation.

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
Module Example
   Public Sub Main()
      Dim flags() As Boolean = { True, False }
      For Each flag In flags
         ' Get binary representation of flag.
         Dim value As Byte = 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.
         Dim newFlag As Boolean = BitConverter.ToBoolean( { value }, 0)
         Console.WriteLine("Restored value: {0}", flag)
         Console.WriteLine()
      Next
   End Sub
   
   Private Function GetBinaryString(value As Byte) As String
      Dim retVal As String = Convert.ToString(value, 2)
      Return New String("0"c, 8 - retVal.Length) + retVal
   End Function
End Module
' 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éennesPerforming operations with Boolean values

Cette section montre comment les valeurs booléennes sont utilisées dans les applications.This section illustrates how Boolean values are used in apps. La première section traite de son utilisation en tant qu’indicateur.The first section discusses its use as a flag. Le deuxième illustre son utilisation pour les opérations arithmétiques.The second illustrates its use for arithmetic operations.

Valeurs booléennes en tant qu’indicateursBoolean values as flags

Les variables booléennes sont généralement utilisées comme indicateurs, pour signaler la présence ou l’absence d’une condition.Boolean variables are most commonly used as flags, to signal the presence or absence of some condition. Par exemple, dans la String.Compare(String, String, Boolean) méthode, le dernier paramètre, ignoreCase, est un indicateur qui indique si la comparaison de deux chaînes ne respecte pas la casse (ignoreCase a truela casse) ou respecte laignoreCase casse false(a la valeur).For example, in the String.Compare(String, String, Boolean) method, the final parameter, ignoreCase, is a flag that indicates whether the comparison of two strings is case-insensitive (ignoreCase is true) or case-sensitive (ignoreCase is false). La valeur de l’indicateur peut ensuite être évaluée dans une instruction conditionnelle.The value of the flag can then be evaluated in a conditional statement.

L’exemple suivant utilise une application console simple pour illustrer l’utilisation de variables booléennes comme indicateurs.The following example uses a simple console app to illustrate the use of Boolean variables as flags. L’application accepte les paramètres de ligne de commande qui permettent de rediriger la sortie vers un fichier spécifié ( /f le commutateur) et qui permet d’envoyer la sortie à la fois vers un fichier spécifié et vers la console /b (le commutateur).The app accepts command-line parameters that enable output to be redirected to a specified file (the /f switch), and that enable output to be sent both to a specified file and to the console (the /b switch). L’application définit un indicateur nommé isRedirected pour indiquer si la sortie doit être envoyée à un fichier et un indicateur nommé isBoth pour indiquer que la sortie doit être envoyée à la console.The app defines a flag named isRedirected to indicate whether output is to be sent to a file, and a flag named isBoth to indicate that output should be sent to the 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");
   }
}
Imports System.IO
Imports System.Threading

Module Example
   Public Sub Main()
      ' Initialize flag variables.
      Dim isRedirected, isBoth As Boolean 
      Dim fileName As String = ""
      Dim sw As StreamWriter = Nothing
      
      ' Get any command line arguments.
      Dim args() As String = Environment.GetCommandLineArgs()
      ' Handle any arguments.
      If args.Length > 1 Then
         For ctr = 1 To args.Length - 1
            Dim arg As String = args(ctr)
            If arg.StartsWith("/") OrElse arg.StartsWith("-") Then
               Select Case arg.Substring(1).ToLower()
                  Case "f"
                     isRedirected = True
                     If args.Length < ctr + 2 Then
                        ShowSyntax("The /f switch must be followed by a filename.")
                        Exit Sub
                     End If
                     fileName = args(ctr + 1)
                     ctr += 1
                  Case "b"
                     isBoth = True
                  Case Else
                     ShowSyntax(String.Format("The {0} switch is not supported", 
                                              args(ctr)))
                     Exit Sub
               End Select
            End If   
         Next
      End If

      ' If isBoth is True, isRedirected must be True.
      If isBoth And Not isRedirected Then 
         ShowSyntax("The /f switch must be used if /b is used.")
         Exit Sub
      End If

      ' Handle output.
      If isRedirected Then
         sw = New StreamWriter(fileName) 
         If Not IsBoth Then
            Console.SetOut(sw) 
         End If
      End If     
      Dim msg As String = String.Format("Application began at {0}", Date.Now)
      Console.WriteLine(msg)
      If isBoth Then sw.WriteLine(msg)
      Thread.Sleep(5000)
      msg = String.Format("Application ended normally at {0}", Date.Now)
      Console.WriteLine(msg)
      If isBoth Then sw.WriteLine(msg)
      If isRedirected Then sw.Close()
   End Sub
   
   Private Sub ShowSyntax(errMsg As String)
      Console.WriteLine(errMsg)
      Console.WriteLine()
      Console.WriteLine("Syntax: Example [[/f <filename> [/b]]")
      Console.WriteLine()
   End Sub
End Module

Opérations booléennes et arithmétiquesBooleans and arithmetic operations

Une valeur booléenne est parfois utilisée pour indiquer la présence d’une condition qui déclenche un calcul mathématique.A Boolean value is sometimes used to indicate the presence of a condition that triggers a mathematical calculation. Par exemple, une hasShippingCharge variable peut servir d’indicateur pour indiquer s’il faut ajouter des frais d’expédition à un montant de facture.For example, a hasShippingCharge variable might serve as a flag to indicate whether to add shipping charges to an invoice amount.

Étant donné qu’une opération false avec une 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 en valeur intégrale à utiliser dans l’opération mathématique.Because an operation with a false value has no effect on the result of an operation, it is not necessary to convert the Boolean to an integral value to use in the mathematical operation. Au lieu de cela, vous pouvez utiliser la logique conditionnelle.Instead, you can use conditional logic.

L’exemple suivant calcule une quantité composée d’un sous-total, de frais d’expédition et de frais de service facultatifs.The following example computes an amount that consists of a subtotal, a shipping charge, and an optional service charge. La hasServiceCharge variable détermine si les frais de service sont appliqués.The hasServiceCharge variable determines whether the service charge is applied. Au lieu de hasServiceCharge convertir une valeur numérique en la multipliant par la quantité de frais de service, l’exemple utilise une logique conditionnelle pour ajouter le montant de frais de service s’il est applicable.Instead of converting hasServiceCharge to a numeric value and multiplying it by the amount of the service charge, the example uses conditional logic to add the service charge amount if it is 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.
Module Example
   Public Sub Main()
      Dim hasServiceCharges() As Boolean = { True, False }
      Dim subtotal As Decimal = 120.62d
      Dim shippingCharge As Decimal = 2.50d
      Dim serviceCharge As Decimal = 5.00d
      
      For Each hasServiceCharge In hasServiceCharges
         Dim total As Decimal = subtotal + shippingCharge + 
                                If(hasServiceCharge, serviceCharge, 0)
         Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.", 
                           total, hasServiceCharge)                       
      Next
   End Sub
End Module
' The example displays output like the following:
'       hasServiceCharge = True: The total is $128.12.
'       hasServiceCharge = False: The total is $123.12.

Valeurs booléennes et InteropBooleans and interop

Si le marshaling des types de données de base en com est Boolean généralement simple, le type de données est une exception.While marshaling base data types to COM is generally straightforward, the Boolean data type is an exception. Vous pouvez appliquer l' MarshalAsAttribute attribut pour marshaler Boolean le type vers l’une des représentations suivantes :You can apply the MarshalAsAttribute attribute to marshal the Boolean type to any of the following representations:

Type d'énumérationEnumeration type Format non managéUnmanaged format
UnmanagedType.Bool Valeur entière de 4 octets, où toute valeur différente de zéro représente true et 0 représente false.A 4-byte integer value, where any nonzero value represents true and 0 represents false. Il s’agit du format par défaut Boolean d’un champ dans une structure et Boolean d’un paramètre dans les appels de code non managé.This is the default format of a Boolean field in a structure and of a Boolean parameter in platform invoke calls.
UnmanagedType.U1 Valeur entière de 1 octet, où 1 représente true et 0 représente. falseA 1-byte integer value, where the 1 represents true and 0 represents false.
UnmanagedType.VariantBool Valeur entière de 2 octets, où-1 représente true et 0 représente. falseA 2-byte integer value, where -1 represents true and 0 represents false. Il s’agit du format par défaut Boolean d’un paramètre dans COM Interop appels.This is the default format of a Boolean parameter in COM interop calls.

Champs

FalseString FalseString FalseString FalseString

Représente la valeur booléenne false sous forme de chaîne.Represents the Boolean value false as a string. Ce champ est en lecture seule.This field is read-only.

TrueString TrueString TrueString TrueString

Représente la valeur booléenne true sous forme de chaîne.Represents the Boolean value true as a string. Ce champ est en lecture seule.This field is read-only.

Méthodes

CompareTo(Boolean) CompareTo(Boolean) CompareTo(Boolean) CompareTo(Boolean)

Compare cette instance à un objet Boolean spécifié et retourne un entier qui indique la relation entre ces deux éléments.Compares this instance to a specified Boolean object and returns an integer that indicates their relationship to one another.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

Compare cette instance à l'objet spécifié et retourne un entier qui indique la relation entre ces deux éléments.Compares this instance to a specified object and returns an integer that indicates their relationship to one another.

Equals(Boolean) Equals(Boolean) Equals(Boolean) Equals(Boolean)

Retourne une valeur indiquant si cette instance est égale à un objet Boolean spécifié.Returns a value indicating whether this instance is equal to a specified Boolean object.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Retourne le code de hachage de cette instance.Returns the hash code for this instance.

GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

Retourne le code de type pour le type valeur Boolean.Returns the type code for the Boolean value type.

Parse(ReadOnlySpan<Char>) Parse(ReadOnlySpan<Char>) Parse(ReadOnlySpan<Char>) Parse(ReadOnlySpan<Char>)
Parse(String) Parse(String) Parse(String) Parse(String)

Convertit la représentation sous forme de chaîne spécifiée d’une valeur logique en son équivalent Boolean.Converts the specified string representation of a logical value to its Boolean equivalent.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

Convertit la valeur de cette instance en sa représentation sous forme de chaîne équivalente ("True" ou "False").Converts the value of this instance to its equivalent string representation (either "True" or "False").

ToString() ToString() ToString() ToString()

Convertit la valeur de cette instance en sa représentation sous forme de chaîne équivalente ("True" ou "False").Converts the value of this instance to its equivalent string representation (either "True" or "False").

TryFormat(Span<Char>, Int32) TryFormat(Span<Char>, Int32) TryFormat(Span<Char>, Int32) TryFormat(Span<Char>, Int32)
TryParse(ReadOnlySpan<Char>, Boolean) TryParse(ReadOnlySpan<Char>, Boolean) TryParse(ReadOnlySpan<Char>, Boolean) TryParse(ReadOnlySpan<Char>, Boolean)
TryParse(String, Boolean) TryParse(String, Boolean) TryParse(String, Boolean) TryParse(String, Boolean)

Tente de convertir la représentation sous forme de chaîne d'une valeur logique en son Boolean équivalent.Tries to convert the specified string representation of a logical value to its Boolean equivalent. Une valeur de retour indique si la conversion a réussi ou a échoué.A return value indicates whether the conversion succeeded or failed.

Implémentations d’interfaces explicites

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)
IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

Cette conversion n'est pas prise en charge.This conversion is not supported. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

Cette conversion n'est pas prise en charge.This conversion is not supported. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider)

Pour obtenir une description de ce membre, consultez ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

S’applique à

Cohérence de thread

Tous les membres de ce type sont thread-safe.All members of this type are thread safe. Les membres qui semblent modifier l’état de l’instance retournent en fait une nouvelle instance initialisée avec la nouvelle valeur.Members that appear to modify instance state actually return a new instance initialized with the new value. Comme pour tout autre type, la lecture et l’écriture dans 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.As with any other type, reading and writing to a shared variable that contains an instance of this type must be protected by a lock to guarantee thread safety.