Boolean Boolean Boolean Boolean Struct

Definición

Representa un valor booleano (true o 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)
Herencia
Atributos
Implementaciones

Comentarios

Un Boolean instancia puede tener uno de dos valores: true, o false.A Boolean instance can have either of two values: true, or false.

El Boolean estructura proporciona métodos que admiten las siguientes tareas:The Boolean structure provides methods that support the following tasks:

Las siguientes secciones explican estas tareas y otros detalles de uso:The following sections explain these tasks and other usage details:

Aplicar formato a valores booleanos Formatting Boolean values
Convertir a y desde valores booleanos Converting to and from Boolean values
Análisis de valores booleanos Parsing Boolean values
Comparación de valores booleanos Comparing Boolean values
Trabajar con valores booleanos como valores binarios Working with Booleans as binary values
Realizar operaciones con valores booleanos Performing operations with Boolean values
Interoperabilidad y valores booleanosBooleans and Interop

Aplicar formato a valores booleanosFormatting Boolean values

La representación de cadena de un Boolean es "True" para un true valor o "False" para un false valor.The string representation of a Boolean is either "True" for a true value or "False" for a false value. La representación de cadena de un Boolean valor está definido por el solo lectura TrueString y FalseString campos.The string representation of a Boolean value is defined by the read-only TrueString and FalseString fields.

Usa el ToString método para convertir los valores booleanos en cadenas.You use the ToString method to convert Boolean values to strings. La estructura de tipo Boolean incluye dos ToString sobrecargas: sin parámetros ToString() método y el ToString(IFormatProvider) método, que incluye un parámetro que controla el formato.The Boolean structure includes two ToString overloads: the parameterless ToString() method and the ToString(IFormatProvider) method, which includes a parameter that controls formatting. Sin embargo, dado que este parámetro se omite, las dos sobrecargas generan cadenas idénticas.However, because this parameter is ignored, the two overloads produce identical strings. El ToString(IFormatProvider) método no admite el formato de la referencia cultural.The ToString(IFormatProvider) method does not support culture-sensitive formatting.

El ejemplo siguiente muestra el formato con el ToString método.The following example illustrates formatting with the ToString method. Tenga en cuenta que el ejemplo se usa el formatos compuestos característica, por lo que el ToString se llama implícitamente al método.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

Dado que el Boolean estructura puede tener solo dos valores, es fácil agregar formato personalizado.Because the Boolean structure can have only two values, it is easy to add custom formatting. Simple formatos en qué otras cadenas literales se sustituyen por "True" y "False", puede utilizar cualquier característica de evaluación condicional admitida por el lenguaje, como el operador condicional en C# o la Si operador en 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. En el ejemplo siguiente se usa esta técnica para dar formato a Boolean valores como "Sí" y "No" en lugar de "True" y "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 operaciones de formato personalizadas más complejas, incluidos el formato de la referencia cultural, se puede llamar a la String.Format(IFormatProvider, String, Object[]) método y proporcionar una ICustomFormatter implementación.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. En el ejemplo siguiente se implementa el ICustomFormatter y IFormatProvider interfaces para proporcionar las cadenas booleanas de referencias culturales de inglés (Estados Unidos), francés (Francia) y las referencias culturales de ruso (Rusia).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 lo desea, puede usar archivos de recursos para definir las cadenas booleanas de referencia cultural específica.Optionally, you can use resource files to define culture-specific Boolean strings.

Convertir a y desde valores booleanosConverting to and from Boolean values

El Boolean estructura implementa el IConvertible interfaz.The Boolean structure implements the IConvertible interface. Como resultado, puede usar el Convert clase para realizar conversiones entre una Boolean valor y cualquier otro tipo primitivo en .NET Framework, o bien pueden llamar a la Boolean implementaciones explícitas de la estructura.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. Sin embargo, las conversiones entre una Boolean y los siguientes tipos no se admiten, por lo que los métodos de conversión correspondiente inician un InvalidCastException excepción:However, conversions between a Boolean and the following types are not supported, so the corresponding conversion methods throw an InvalidCastException exception:

Todas las conversiones de números enteros o de punto flotante en valores booleanos conversión valores distintos de cero a true y valores cero a false.All conversions from integral or floating-point numbers to Boolean values convert non-zero values to true and zero values to false. El ejemplo siguiente ilustra esto mediante una llamada a sobrecargas seleccionadas de la Convert.ToBoolean clase.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

Al convertir valores de punto flotante en valores booleanos, los métodos de conversión realizan una comparación exacta con cero.When converting from floating-point values to Boolean values, the conversion methods perform an exact comparison with zero. Si el valor de punto flotante ha perdido precisión, el resultado puede ser inesperado.If the floating-point value has lost precision, the result can be unexpected. Esto se muestra en el ejemplo siguiente, en el que un Double variable cuyo valor debe ser cero se convierte en un valor booleano.This is illustrated in the following example, in which a Double variable whose value should be zero is converted to a Boolean value. Como se muestra en el ejemplo, el resultado es true dado que las adiciones de 0,2 tener como resultado una pérdida de precisión.As the example shows, the result is true because repeated additions of 0.2 have resulted in a loss of precision.

Al convertir de un valor booleano para valores numéricos, los métodos de conversión de la Convert clase convert true en 1 y false en 0.When converting from Boolean to numeric values, the conversion methods of the Convert class convert true to 1 and false to 0. Sin embargo, funciones de conversión de Visual Basic convierten true a cualquier 255 (para las conversiones a Byte valores) o -1 (para todas las demás conversiones numéricas).However, Visual Basic conversion functions convert true to either 255 (for conversions to Byte values) or -1 (for all other numeric conversions). El ejemplo siguiente convierte true en valores numéricos mediante el uso de un Convert método y, en el caso de ejemplo de Visual Basic, mediante el operador de conversión de Visual Basic del lenguaje propio.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)

En las conversiones de Boolean a valores de cadena, vea la dar formato a valores booleanos sección.For conversions from Boolean to string values, see the Formatting Boolean Values section. En las conversiones de cadenas para Boolean valores, vea el analizar valores booleanos sección.For conversions from strings to Boolean values, see the Parsing Boolean Values section.

Análisis de valores booleanosParsing Boolean values

El Boolean estructura incluye dos métodos de análisis estáticos, Parse y TryParse, que convierte una cadena en un valor booleano.The Boolean structure includes two static parsing methods, Parse and TryParse, that convert a string to a Boolean value. La representación de cadena de un valor booleano se define mediante los equivalentes de mayúsculas y minúsculas de los valores de la TrueString y FalseString campos, que son "True" y "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. En otras palabras, las cadenas únicas que se analizan correctamente son "True", "False", "true", "false" o algún equivalente en mayúsculas y minúsculas mezcladas.In other words, the only strings that parse successfully are "True", "False", "true", "false", or some mixed-case equivalent. No se puede analizar correctamente las cadenas numéricas como "0" o "1".You cannot successfully parse numeric strings such as "0" or "1". No se consideran caracteres de espacio en blanco iniciales o finales al realizar la comparación de cadenas.Leading or trailing white-space characters are not considered when performing the string comparison.

En el ejemplo siguiente se usa el Parse y TryParse métodos para analizar un número de cadenas.The following example uses the Parse and TryParse methods to parse a number of strings. Tenga en cuenta que solo los equivalentes de mayúsculas y minúsculas de "True" y "False" se pueden analizar correctamente.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 está programando en Visual Basic, puede usar el CBool función para convertir la representación de cadena de un número en un valor booleano.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" se convierte en false, y la representación de cadena de cualquier valor distinto de cero se convierte en true."0" is converted to false, and the string representation of any non-zero value is converted to true. Si no está programando en Visual Basic, debe convertir la cadena numérica en un número antes de convertirlo en un valor booleano.If you are not programming in Visual Basic, you must convert your numeric string to a number before converting it to a Boolean. El ejemplo siguiente ilustra esto mediante la conversión de una matriz de enteros en valores booleanos.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

Comparación de valores booleanosComparing Boolean values

Debido a que los valores booleanos son true o false, hay pocas razones para llamar explícitamente a la CompareTo método, que indica si una instancia es mayor que, menor que, o es igual a un 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 dos variables booleanas, se llama a la Equals método o use el operador de igualdad de su lenguaje.Typically, to compare two Boolean variables, you call the Equals method or use your language's equality operator.

Sin embargo, cuando desea comparar una variable booleana con el valor literal booleano true o false, no es necesario realizar una comparación explícita, dado que el resultado de evaluar un valor booleano es ese valor booleano.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 ejemplo, las expresionesFor example, the expressions

if (booleanValue) {
If booleanValue Then

yand

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.

son equivalentes, pero el segundo es más compacto.are equivalent, but the second is more compact. Sin embargo, ambas técnicas ofrecen un rendimiento comparable.However, both techniques offer comparable performance.

Trabajar con valores booleanos como valores binariosWorking with Booleans as binary values

Un valor booleano ocupa un byte de memoria, como C# muestra el ejemplo siguiente.A Boolean value occupies one byte of memory, as the following C# example shows. El ejemplo debe compilarse con la /unsafe cambie.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

Bit de orden inferior del byte se utiliza para representar su valor.The byte's low-order bit is used to represent its value. Representa un valor de 1 true; el valor 0 representa false.A value of 1 represents true; a value of 0 represents false.

Advertencia

Puede usar el System.Collections.Specialized.BitVector32 estructura para trabajar con conjuntos de valores booleanos.You can use the System.Collections.Specialized.BitVector32 structure to work with sets of Boolean values.

Puede convertir un valor booleano en su representación binaria mediante una llamada a la BitConverter.GetBytes(Boolean) método.You can convert a Boolean value to its binary representation by calling the BitConverter.GetBytes(Boolean) method. El método devuelve una matriz de bytes con un solo elemento.The method returns a byte array with a single element. Para restaurar un valor booleano de la representación binaria, puede llamar a la BitConverter.ToBoolean(Byte[], Int32) método.To restore a Boolean value from its binary representation, you can call the BitConverter.ToBoolean(Byte[], Int32) method.

El ejemplo siguiente se llama el BitConverter.GetBytes método para convertir un valor booleano a su representación binaria y muestra los bits individuales de valor y, a continuación, llama el BitConverter.ToBoolean método para restaurar el valor de su representación binaria.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

Realizar operaciones con valores booleanosPerforming operations with Boolean values

En esta sección muestra los valores booleanos en cómo se usan en las aplicaciones.This section illustrates how Boolean values are used in apps. La primera sección describe su uso como una marca.The first section discusses its use as a flag. La segunda muestra su uso para las operaciones aritméticas.The second illustrates its use for arithmetic operations.

Valores booleanos como marcasBoolean values as flags

Las variables booleanas se usan normalmente como marcadores, para indicar la presencia o ausencia de alguna condición.Boolean variables are most commonly used as flags, to signal the presence or absence of some condition. Por ejemplo, en el String.Compare(String, String, Boolean) método, el último parámetro, ignoreCase, es una marca que indica si la comparación de dos cadenas distingue entre mayúsculas y minúsculas (ignoreCase es true) o entre mayúsculas y minúsculas (ignoreCase es 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). A continuación, se puede evaluar el valor de la marca en una instrucción condicional.The value of the flag can then be evaluated in a conditional statement.

El ejemplo siguiente utiliza una aplicación de consola simple para ilustrar el uso de las variables booleanas como marcas.The following example uses a simple console app to illustrate the use of Boolean variables as flags. La aplicación acepta parámetros de línea de comandos que permiten la salida se redirige a un archivo especificado (el /f cambiar), y que permiten la salida se envíen en un archivo especificado y en la consola (el /b cambiar).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). La aplicación define un marcador denominado isRedirected para indicar si es de salida para enviarse a un archivo y un indicador denominado isBoth para indicar que se debe enviar la salida a la consola.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

Valores booleanos y operaciones aritméticasBooleans and arithmetic operations

A veces se utiliza un valor booleano para indicar la presencia de una condición que desencadenará un cálculo matemático.A Boolean value is sometimes used to indicate the presence of a condition that triggers a mathematical calculation. Por ejemplo, un hasShippingCharge variable podría servir como una marca para indicar si desea agregar los gastos de envío a un importe de factura.For example, a hasShippingCharge variable might serve as a flag to indicate whether to add shipping charges to an invoice amount.

Dado que una operación con un false valor no tiene ningún efecto en el resultado de una operación, no es necesario convertir el valor booleano en un valor entero para usar en la operación 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. En su lugar, puede usar lógica condicional.Instead, you can use conditional logic.

El siguiente ejemplo calcula una cantidad que consta de un subtotal, gastos de envío y un cargo de servicio opcional.The following example computes an amount that consists of a subtotal, a shipping charge, and an optional service charge. El hasServiceCharge variable determina si se aplica el cargo de servicio.The hasServiceCharge variable determines whether the service charge is applied. En lugar de convertir hasServiceCharge a un valor numérico y multiplicándola por la cantidad del cargo por servicio, en el ejemplo se usa lógica condicional para agregar el cargo de servicio si es aplicable.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.

Interoperabilidad y valores booleanosBooleans and interop

Mientras la serialización de tipos de datos base para COM es sencillo con carácter general, la Boolean tipo de datos es una excepción.While marshaling base data types to COM is generally straightforward, the Boolean data type is an exception. Puede aplicar el MarshalAsAttribute atributo para serializar el Boolean tipo a cualquiera de las representaciones de la siguientes:You can apply the MarshalAsAttribute attribute to marshal the Boolean type to any of the following representations:

Tipo de enumeraciónEnumeration type Formato no administradoUnmanaged format
UnmanagedType.Bool Un valor entero de 4 bytes, donde cualquier valor distinto de cero representa true y 0 representa false.A 4-byte integer value, where any nonzero value represents true and 0 represents false. Este es el formato predeterminado de un Boolean campo en una estructura y de un Boolean llamadas de invocación de parámetro en la plataforma.This is the default format of a Boolean field in a structure and of a Boolean parameter in platform invoke calls.
UnmanagedType.U1 Un valor entero de 1 byte, donde el 1 representa true y 0 representa false.A 1-byte integer value, where the 1 represents true and 0 represents false.
UnmanagedType.VariantBool Un valor entero de 2 bytes, donde -1 representa true y 0 representa false.A 2-byte integer value, where -1 represents true and 0 represents false. Este es el formato predeterminado de un Boolean parámetro en las llamadas de interoperabilidad COM.This is the default format of a Boolean parameter in COM interop calls.

Campos

FalseString FalseString FalseString FalseString

Representa el valor booleano false como una cadena.Represents the Boolean value false as a string. Este campo es de solo lectura.This field is read-only.

TrueString TrueString TrueString TrueString

Representa el valor booleano true como una cadena.Represents the Boolean value true as a string. Este campo es de solo lectura.This field is read-only.

Métodos

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

Compara esta instancia con un objeto Boolean especificado y devuelve un entero que indica la relación entre ambos.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 esta instancia con un objeto especificado y devuelve un entero que indica la relación entre ambos.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)

Devuelve un valor que indica si esta instancia equivale a un 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)

Devuelve un valor que indica si esta instancia equivale a un objeto especificado.Returns a value indicating whether this instance is equal to a specified object.

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

Devuelve el código hash de esta instancia.Returns the hash code for this instance.

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

Devuelve el código de tipo para el 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)

Convierte la representación de cadena especificada de un valor lógico en su valor Boolean equivalente.Converts the specified string representation of a logical value to its Boolean equivalent.

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

Convierte el valor de esta instancia en la representación de cadena equivalente ("True" o "False").Converts the value of this instance to its equivalent string representation (either "True" or "False").

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

Convierte el valor de esta instancia en la representación de cadena equivalente ("True" o "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)

Intenta convertir la representación de cadena que se haya especificado para un valor lógico en su valor Boolean equivalente.Tries to convert the specified string representation of a logical value to its Boolean equivalent. Un valor devuelto indica si la conversión se realizó correctamente o si se produjeron errores.A return value indicates whether the conversion succeeded or failed.

Implementaciones de interfaz explícitas

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 obtener una descripción de este miembro, vea ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

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

Para obtener una descripción de este miembro, vea ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

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

No se admite esta conversión.This conversion is not supported. Cualquier intento de usar este método produce una excepción InvalidCastException.Attempting to use this method throws an InvalidCastException.

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

No se admite esta conversión.This conversion is not supported. Cualquier intento de usar este método produce una excepción InvalidCastException.Attempting to use this method throws an InvalidCastException.

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

Para obtener una descripción de este miembro, vea ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

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

Para obtener una descripción de este miembro, vea ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

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

Para obtener una descripción de este miembro, vea ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

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

Para obtener una descripción de este miembro, vea ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

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

Para obtener una descripción de este miembro, vea ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

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

Para obtener una descripción de este miembro, vea ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

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

Para una descripción de este miembro, vea 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 una descripción de este miembro, vea 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 obtener una descripción de este miembro, vea ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

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

Para obtener una descripción de este miembro, vea ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

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

Para obtener una descripción de este miembro, vea ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

Se aplica a

Seguridad para subprocesos

Todos los miembros de este tipo son seguros para subprocesos.All members of this type are thread safe. Los miembros que aparecen modificar el estado de instancia devuelven realmente una nueva instancia inicializada con el nuevo valor.Members that appear to modify instance state actually return a new instance initialized with the new value. Como con cualquier otro tipo, leer y escribir en una variable compartida que contiene una instancia de este tipo deben protegerse mediante un bloqueo para garantizar la seguridad para subprocesos.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.