Boolean Boolean Boolean Boolean Struct

Definição

Representa um valor booliano (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)
Herança
Atributos
Implementações

Comentários

Um Boolean instância pode ter qualquer um dos dois valores: true, ou false.A Boolean instance can have either of two values: true, or false.

O Boolean estrutura fornece métodos que suportam as seguintes tarefas:The Boolean structure provides methods that support the following tasks:

As seções a seguir explicam essas tarefas e outros detalhes de uso:The following sections explain these tasks and other usage details:

Formatação de valores boolianos Formatting Boolean values
Conversão de e para valores boolianos Converting to and from Boolean values
A análise de valores boolianos Parsing Boolean values
Comparando valores booleanos Comparing Boolean values
Trabalhando com boolianos como valores binários Working with Booleans as binary values
Executando operações com valores booleanos Performing operations with Boolean values
Interoperabilidade e boolianosBooleans and Interop

Formatação de valores boolianosFormatting Boolean values

A representação de cadeia de caracteres de um Boolean é "True" para um true valor ou "False" para um false valor.The string representation of a Boolean is either "True" for a true value or "False" for a false value. A representação de cadeia de caracteres de um Boolean valor é definido pela somente leitura TrueString e FalseString campos.The string representation of a Boolean value is defined by the read-only TrueString and FalseString fields.

Você usa o ToString método para converter valores boolianos em cadeias de caracteres.You use the ToString method to convert Boolean values to strings. A estrutura de booliana inclui dois ToString sobrecargas: sem o parâmetro ToString() método e o ToString(IFormatProvider) método, que inclui um parâmetro que controla a formatação.The Boolean structure includes two ToString overloads: the parameterless ToString() method and the ToString(IFormatProvider) method, which includes a parameter that controls formatting. No entanto, uma vez que esse parâmetro é ignorado, duas sobrecargas produzem cadeias de caracteres idênticas.However, because this parameter is ignored, the two overloads produce identical strings. O ToString(IFormatProvider) método não dá suporte a formatação sensível à cultura.The ToString(IFormatProvider) method does not support culture-sensitive formatting.

O exemplo a seguir ilustra a formatação com o ToString método.The following example illustrates formatting with the ToString method. Observe que o exemplo usa o formatação composta recurso, portanto, o ToString método é chamado implicitamente.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

Porque o Boolean estrutura pode ter apenas dois valores, é fácil adicionar formatação personalizada.Because the Boolean structure can have only two values, it is easy to add custom formatting. Simples formatação personalizada na qual outra cadeia de caracteres literais são substituídos por "Verdadeiro" e "False", você pode usar qualquer recurso de avaliação condicional suportado por seu idioma, como o operador condicional em C# ou o Se operador no 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. O exemplo a seguir usa essa técnica para formatar Boolean valores como "Sim" e "Não" em vez de "True" e "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

Para mais complexas operações de formatação personalizadas, incluindo formatação sensível à cultura, você pode chamar o String.Format(IFormatProvider, String, Object[]) método e fornecer um ICustomFormatter implementação.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. O exemplo a seguir implementa o ICustomFormatter e IFormatProvider interfaces para fornecer Boolianas sensíveis à cultura de cadeias de caracteres para o inglês (Estados Unidos), francês (França) e culturas russo (Rússia).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': верно

Opcionalmente, você pode usar arquivos de recurso para definir as cadeias de caracteres Boolianas específicas da cultura.Optionally, you can use resource files to define culture-specific Boolean strings.

Conversão de e para valores boolianosConverting to and from Boolean values

O Boolean estrutura implementa o IConvertible interface.The Boolean structure implements the IConvertible interface. Como resultado, você pode usar o Convert classe para realizar conversões entre uma Boolean valor e qualquer outro tipo primitivo no .NET Framework, ou você podem chamar o Boolean implementações explícitas da estrutura.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. No entanto, as conversões entre uma Boolean e os seguintes tipos não têm suporte, portanto, os métodos de conversão correspondente geram um InvalidCastException exceção:However, conversions between a Boolean and the following types are not supported, so the corresponding conversion methods throw an InvalidCastException exception:

Todas as conversões de números de ponto flutuantes ou integrais para valores boolianos convertem valores diferentes de zero a true e valores zero para false.All conversions from integral or floating-point numbers to Boolean values convert non-zero values to true and zero values to false. O exemplo a seguir ilustra isso chamando as sobrecargas selecionadas do 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

Ao converter valores de ponto flutuante em valores boolianos, os métodos de conversão realizam uma comparação exata com zero.When converting from floating-point values to Boolean values, the conversion methods perform an exact comparison with zero. Se o valor de ponto flutuante perdeu a precisão, o resultado pode ser inesperado.If the floating-point value has lost precision, the result can be unexpected. Isso é ilustrado no exemplo a seguir, no qual um Double variável cujo valor deve ser zero é convertida em um valor booliano.This is illustrated in the following example, in which a Double variable whose value should be zero is converted to a Boolean value. Como mostra o exemplo, o resultado é true pois repetida adições de 0,2 resultaram em uma perda de precisão.As the example shows, the result is true because repeated additions of 0.2 have resulted in a loss of precision.

Ao converter de booliano em valores numéricos, os métodos de conversão do Convert classe convert true como 1 e false como 0.When converting from Boolean to numeric values, the conversion methods of the Convert class convert true to 1 and false to 0. No entanto, convertem funções de conversão do Visual Basic true a qualquer um dos 255 (para conversões em Byte valores) ou -1 (para todas as outras conversões numéricas).However, Visual Basic conversion functions convert true to either 255 (for conversions to Byte values) or -1 (for all other numeric conversions). O exemplo a seguir converte true em valores numéricos, usando um Convert método e, no caso do exemplo do Visual Basic, usando o operador de conversão do Visual Basic da linguagem próprios.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)

Para conversões de Boolean valores de cadeia de caracteres, consulte a formatação de valores boolianos seção.For conversions from Boolean to string values, see the Formatting Boolean Values section. Para conversões de cadeias de caracteres Boolean valores, consulte a análise de valores boolianos seção.For conversions from strings to Boolean values, see the Parsing Boolean Values section.

A análise de valores boolianosParsing Boolean values

O Boolean estrutura inclui dois métodos de análise estáticos Parse e TryParse, que converter uma cadeia de caracteres em um valor booliano.The Boolean structure includes two static parsing methods, Parse and TryParse, that convert a string to a Boolean value. A representação de cadeia de caracteres de um valor booliano é definida pelos equivalentes de maiusculas e minúsculas dos valores da TrueString e FalseString campos, que são "True" e "False", respectivamente.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. Em outras palavras, somente cadeias de caracteres que são analisados com êxito são "True", "False", "true", "false" ou algum equivalente em maiusculas e minúsculas.In other words, the only strings that parse successfully are "True", "False", "true", "false", or some mixed-case equivalent. Você não pode analisar cadeias de caracteres numéricas, como "0" ou "1" com êxito.You cannot successfully parse numeric strings such as "0" or "1". Caracteres de espaço em branco à esquerda ou direita não são considerados ao executar a comparação de cadeia de caracteres.Leading or trailing white-space characters are not considered when performing the string comparison.

O exemplo a seguir usa o Parse e TryParse métodos para analisar um número de cadeias de caracteres.The following example uses the Parse and TryParse methods to parse a number of strings. Observe que somente os equivalentes maiusculas de minúsculas de "True" e "False" podem ser analisados com êxito.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'

Se você estiver programando no Visual Basic, você pode usar o CBool função para converter a representação de cadeia de caracteres de um número em um valor booliano.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" é convertido em false, e a representação de cadeia de caracteres de qualquer valor diferente de zero é convertida em true."0" is converted to false, and the string representation of any non-zero value is converted to true. Se você não estiver programando no Visual Basic, você deve converter sua cadeia de caracteres numérica como um número antes da conversão em booliano.If you are not programming in Visual Basic, you must convert your numeric string to a number before converting it to a Boolean. O exemplo a seguir ilustra isso ao converter uma matriz de inteiros em valores boolianos.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

Comparando valores booleanosComparing Boolean values

Porque os valores boolianos são true ou false, há poucos motivos para chamar explicitamente o CompareTo método, que indica se uma instância é maior que, menor que, ou igual ao valor especificado.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. Normalmente, para comparar duas variáveis Boolianas, você chama o Equals método ou use o operador de igualdade da sua linguagem.Typically, to compare two Boolean variables, you call the Equals method or use your language's equality operator.

No entanto, quando você deseja comparar uma variável booliana com o valor booliano literal true ou false, não é necessário fazer uma comparação explícita, porque o resultado da avaliação de um valor booliano é esse valor booliano.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. Por exemplo, as expressõesFor example, the expressions

if (booleanValue) {
If booleanValue Then

eand

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.

são equivalentes, mas a segunda é mais compacto.are equivalent, but the second is more compact. No entanto, ambas as técnicas oferecem um desempenho comparável.However, both techniques offer comparable performance.

Trabalhando com boolianos como valores bináriosWorking with Booleans as binary values

Um valor booliano ocupa um byte de memória, como C# mostra o exemplo abaixo.A Boolean value occupies one byte of memory, as the following C# example shows. O exemplo deve ser compilado com o /unsafe alternar.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

O bit de ordem inferior do byte é usado para representar seu valor.The byte's low-order bit is used to represent its value. Um valor de 1 representa true; um valor de 0 representa false.A value of 1 represents true; a value of 0 represents false.

Aviso

Você pode usar o System.Collections.Specialized.BitVector32 estrutura para trabalhar com conjuntos de valores boolianos.You can use the System.Collections.Specialized.BitVector32 structure to work with sets of Boolean values.

Você pode converter um valor booliano em sua representação binária chamando o BitConverter.GetBytes(Boolean) método.You can convert a Boolean value to its binary representation by calling the BitConverter.GetBytes(Boolean) method. O método retorna uma matriz de bytes com um único elemento.The method returns a byte array with a single element. Para restaurar um valor booliano de sua representação binária, você pode chamar o BitConverter.ToBoolean(Byte[], Int32) método.To restore a Boolean value from its binary representation, you can call the BitConverter.ToBoolean(Byte[], Int32) method.

A exemplo a seguir chama o BitConverter.GetBytes método para converter um valor booliano em sua representação binária e exibe os bits individuais do valor e, em seguida, chama o BitConverter.ToBoolean método para restaurar o valor de sua representação binária.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

Executando operações com valores booleanosPerforming operations with Boolean values

Esta seção ilustra valores boolianos como são usadas em aplicativos.This section illustrates how Boolean values are used in apps. A primeira seção discute o uso como um sinalizador.The first section discusses its use as a flag. O segundo ilustra seu uso para operações aritméticas.The second illustrates its use for arithmetic operations.

Valores boolianos como sinalizadoresBoolean values as flags

Variáveis Boolianas são mais comumente usadas como sinalizadores, para indicar a presença ou ausência de alguma condição.Boolean variables are most commonly used as flags, to signal the presence or absence of some condition. Por exemplo, nos String.Compare(String, String, Boolean) método, o parâmetro final, ignoreCase, é um sinalizador que indica se a comparação de duas cadeias de caracteres diferencia maiusculas de minúsculas (ignoreCase é true) ou diferencia maiusculas de minúsculas (ignoreCase é false).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). O valor do sinalizador, em seguida, pode ser avaliado em uma instrução condicional.The value of the flag can then be evaluated in a conditional statement.

O exemplo a seguir usa um aplicativo de console simples para ilustrar o uso de variáveis Boolianas como sinalizadores.The following example uses a simple console app to illustrate the use of Boolean variables as flags. O aplicativo aceita parâmetros de linha de comando que permitem a saída seja redirecionada para um arquivo especificado (o /f alternar), e que permitem a saída a ser enviada para um arquivo especificado e para o console (o /b alternar).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). O aplicativo define um sinalizador denominado isRedirected para indicar se é de saída a serem enviados para um arquivo e um sinalizador chamado isBoth para indicar que a saída deve ser enviada para o 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

Boolianos e operações aritméticasBooleans and arithmetic operations

Um valor booliano, às vezes, é usado para indicar a presença de uma condição que dispara um cálculo matemático.A Boolean value is sometimes used to indicate the presence of a condition that triggers a mathematical calculation. Por exemplo, um hasShippingCharge variável pode servir como um sinalizador para indicar se deseja adicionar as taxas de envio para um valor da nota fiscal.For example, a hasShippingCharge variable might serve as a flag to indicate whether to add shipping charges to an invoice amount.

Porque uma operação com um false valor não tem nenhum efeito no resultado de uma operação, não é necessário converter o valor booliano em um valor integral para usar na operação matemática.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. Em vez disso, você pode usar lógica condicional.Instead, you can use conditional logic.

O exemplo a seguir calcula um valor que consiste em um encargo de serviço opcional, um encargo de remessa e um subtotal.The following example computes an amount that consists of a subtotal, a shipping charge, and an optional service charge. O hasServiceCharge variável determina se o encargo de serviço é aplicado.The hasServiceCharge variable determines whether the service charge is applied. Em vez de converter hasServiceCharge multiplicá-lo pela quantidade de encargo de serviço e um valor numérico, o exemplo usa lógica condicional para adicionar a quantidade de encargo de serviço se ele for aplicável.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.

Interoperabilidade e boolianosBooleans and interop

Enquanto o marshaling de tipos de dados base para o COM é geralmente simples, o Boolean tipo de dados é uma exceção.While marshaling base data types to COM is generally straightforward, the Boolean data type is an exception. Você pode aplicar o MarshalAsAttribute atributo para empacotar o Boolean tipo para qualquer uma das representações a seguir:You can apply the MarshalAsAttribute attribute to marshal the Boolean type to any of the following representations:

Tipo de enumeraçãoEnumeration type Formato não gerenciadoUnmanaged format
UnmanagedType.Bool Um valor inteiro de 4 bytes, onde qualquer valor diferente de zero representa true e 0 representa false.A 4-byte integer value, where any nonzero value represents true and 0 represents false. Este é o formato padrão de um Boolean campo em uma estrutura e de um Boolean chamadas de invocação de parâmetro na plataforma.This is the default format of a Boolean field in a structure and of a Boolean parameter in platform invoke calls.
UnmanagedType.U1 Um valor inteiro de 1 byte, em que o 1 representa true e 0 representa false.A 1-byte integer value, where the 1 represents true and 0 represents false.
UnmanagedType.VariantBool Um valor inteiro de 2 bytes, onde -1 representa true e 0 representa false.A 2-byte integer value, where -1 represents true and 0 represents false. Este é o formato padrão de um Boolean parâmetro em chamadas de interoperabilidade COM.This is the default format of a Boolean parameter in COM interop calls.

Campos

FalseString FalseString FalseString FalseString

Representa o valor booliano false como uma cadeia de caracteres.Represents the Boolean value false as a string. Este campo é somente leitura.This field is read-only.

TrueString TrueString TrueString TrueString

Representa o valor booliano true como uma cadeia de caracteres.Represents the Boolean value true as a string. Este campo é somente leitura.This field is read-only.

Métodos

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

Compara essa instância com um objeto Boolean especificado e retorna um inteiro que indica a relação entre eles.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)

Compara essa instância com um objeto especificado e retorna um inteiro que indica a relação entre eles.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)

Retorna um valor que indica se essa instância é igual a um objeto Boolean especificado.Returns a value indicating whether this instance is equal to a specified Boolean object.

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

Retorna um valor que indica se essa instância é igual a um objeto especificado.Returns a value indicating whether this instance is equal to a specified object.

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

Retorna o código hash para essa instância.Returns the hash code for this instance.

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

Retorna o código de tipo para o tipo de valor 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)

Converte a representação de cadeia de caracteres especificada de um valor lógico em seu Boolean equivalente.Converts the specified string representation of a logical value to its Boolean equivalent.

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

Converte o valor dessa instância na representação da cadeia de caracteres equivalente ("True" ou "False").Converts the value of this instance to its equivalent string representation (either "True" or "False").

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

Converte o valor dessa instância na representação da cadeia de caracteres equivalente ("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)

Tenta converter a representação de cadeia de caracteres especificada de um valor lógico em seu Boolean equivalente.Tries to convert the specified string representation of a logical value to its Boolean equivalent. Um valor de retorno indica se a conversão foi bem-sucedida ou falhou.A return value indicates whether the conversion succeeded or failed.

Implantações explícitas de interface

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)

Para obter uma descrição desse membro, consulte ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

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

Para obter uma descrição desse membro, consulte ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

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

Esta conversão não é suportada.This conversion is not supported. A tentativa de usar esse método lança um InvalidCastException.Attempting to use this method throws an InvalidCastException.

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

Esta conversão não é suportada.This conversion is not supported. A tentativa de usar esse método lança um InvalidCastException.Attempting to use this method throws an InvalidCastException.

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

Para obter uma descrição desse membro, consulte ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

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

Para obter uma descrição desse membro, consulte ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

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

Para obter uma descrição desse membro, consulte ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

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

Para obter uma descrição desse membro, consulte ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

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

Para obter uma descrição desse membro, consulte ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

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

Para obter uma descrição desse membro, consulte ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

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

Para obter uma descrição desse membro, consulte 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)

Para obter uma descrição desse membro, consulte 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)

Para obter uma descrição desse membro, consulte ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

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

Para obter uma descrição desse membro, consulte ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

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

Para obter uma descrição desse membro, consulte ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

Aplica-se a

Acesso thread-safe

Todos os membros desse tipo são thread-safe.All members of this type are thread safe. Os membros que aparentam modificar efetivamente o estado retornam uma nova instância inicializada com o novo valor.Members that appear to modify instance state actually return a new instance initialized with the new value. Assim como acontece com qualquer outro tipo, a leitura e a gravação em uma variável compartilhada que contém uma instância desse tipo devem ser protegidas por um bloqueio para garantir thread-safe.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.