Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Estructura Boolean

 

Publicado: octubre de 2016

Representa un valor booleano (true o false).

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

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

NombreDescripción
System_CAPS_pubmethodCompareTo(Boolean)

Compara esta instancia con un objeto Boolean especificado y devuelve un entero que indica la relación entre ambos.

System_CAPS_pubmethodCompareTo(Object)

Compara esta instancia con un objeto especificado y devuelve un entero que indica la relación entre ambos.

System_CAPS_pubmethodEquals(Boolean)

Devuelve un valor que indica si esta instancia equivale a un objeto Boolean especificado.

System_CAPS_pubmethodEquals(Object)

Devuelve un valor que indica si esta instancia equivale a un objeto especificado.(Invalida ValueType.Equals(Object)).

System_CAPS_pubmethodGetHashCode()

Devuelve el código hash de esta instancia.(Invalida ValueType.GetHashCode()).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodGetTypeCode()

Devuelve el código de tipo para el Boolean un tipo de valor.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Convierte la representación de cadena especificada de un valor lógico en su valor Boolean equivalente.

System_CAPS_pubmethodToString()

Convierte el valor de esta instancia en la representación de cadena equivalente ("True" o "False").(Invalida ValueType.ToString()).

System_CAPS_pubmethodToString(IFormatProvider)

Convierte el valor de esta instancia en la representación de cadena equivalente ("True" o "False").

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Boolean)

Intenta convertir la representación de cadena que se haya especificado para un valor lógico en su valor Boolean equivalente. Un valor devuelto indica si la conversión se realizó correctamente o si se produjeron errores.

NombreDescripción
System_CAPS_pubfieldSystem_CAPS_staticFalseString

Representa el valor booleano false como una cadena. Este campo es de solo lectura.

System_CAPS_pubfieldSystem_CAPS_staticTrueString

Representa el valor booleano true como una cadena. Este campo es de solo lectura.

NombreDescripción
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para obtener una descripción de este miembro, vea IConvertible.ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para obtener una descripción de este miembro, vea IConvertible.ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para obtener una descripción de este miembro, vea IConvertible.ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToUInt64.

A Boolean instancia puede tener uno de dos valores: true, o false.

El Boolean estructura proporciona métodos que admiten las siguientes tareas:

Las siguientes secciones explican estas tareas y otros detalles de uso:

Aplicar formato a valores booleanos
Convertir a y desde los valores booleanos
Análisis valores booleanos
Comparar valores booleanos
Trabajar con valores booleanos como valores binarios
Realizar operaciones con valores booleanos
Valores booleanos e interoperabilidad

La representación de cadena de un Boolean es "True" para un true valor o "False" para un false valor. La representación de cadena de un Boolean valor lo define solo lectura TrueString y FalseString campos.

Usa el ToString método para convertir valores booleanos en cadenas. La estructura booleana incluye dos ToString sobrecargas: sin parámetros ToString() método y ToString(IFormatProvider) método, que incluye un parámetro que controla el formato. Sin embargo, dado que este parámetro se omite, las dos sobrecargas generan cadenas idénticas. El ToString(IFormatProvider) método no admite el formato dependiente de la referencia cultural.

En el ejemplo siguiente se muestra el formato con el ToString método. Tenga en cuenta que el ejemplo se utiliza la formatos compuestos característica, por lo que el ToString se llama implícitamente al método.

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

Dado que el Boolean estructura puede tener solo dos valores, resulta muy sencillo agregar formato personalizado. Para simple formato personalizado en otra cadena, lo literales se sustituyen por "True" y "False", puede utilizar cualquier característica de evaluación condicional admitido por el lenguaje, como el operador condicional en C# o la si operador en Visual Basic. En el ejemplo siguiente se utiliza esta técnica para dar formato Boolean valores como "Sí" y "No" en lugar de "True" y "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

Para operaciones de formato personalizadas más complejas, incluidos el formato dependiente de la referencia cultural, puede llamar a la String.Format(IFormatProvider, String, Object[]) método y proporcionar una ICustomFormatter implementación. En el ejemplo siguiente se implementa el ICustomFormatter y IFormatProvider interfaces para proporcionar cadenas booleanas culturales de inglés (Estados Unidos), francés (Francia) y referencias culturales ruso (Rusia).

using System;
using System.Globalization;

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

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

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

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

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

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

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

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

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

Si lo desea, puede usar archivos de recursos para definir cadenas de referencia cultural booleanas.

El Boolean estructura implementa la IConvertible interfaz. Como resultado, puede usar el Convert clase para realizar conversiones entre un Boolean valor y cualquier otro tipo primitivo en .NET Framework, o pueden llamar a la Boolean las implementaciones explícitas de la estructura. Sin embargo, las conversiones entre un Boolean y los siguientes tipos no se admiten, por lo que los métodos de conversión correspondiente inician un InvalidCastException excepción:

Todas las conversiones de números enteros o de punto flotante en valores booleanos convierten valores distintos de cero para true y valores cero a false. El siguiente ejemplo ilustra esto mediante una llamada a sobrecargas seleccionadas de la Convert.ToBoolean clase.

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

Al convertir valores de punto flotante en valores booleanos, los métodos de conversión realizan una comparación exacta con cero. Si el valor de punto flotante ha perdido la precisión, el resultado puede ser inesperado. Esto se ilustra en el ejemplo siguiente, en el que un Double variable cuyo valor debe ser cero se convierte en un valor booleano. Como se muestra en el ejemplo, el resultado es true porque repite las adiciones de 0,2 tener como resultado una pérdida de precisión.

Al convertir de un valor booleano a valores numéricos, los métodos de conversión de la Convert clase convert true en 1 y false en 0. Sin embargo, funciones de conversión de Visual Basic convierten true y cualquier 255 (para las conversiones a Byte valores) o -1 (para todas las demás conversiones numéricas). El ejemplo siguiente se convierte true en valores numéricos utilizando 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.

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

Para las conversiones de Boolean a valores de cadena, vea la dar formato a valores booleanos sección. Para las conversiones de cadenas a Boolean valores, consulte el analizar valores booleanos sección.

El Boolean estructura incluye dos métodos de análisis estáticos, Parse y TryParse, que convertir una cadena en un valor booleano. La representación de cadena de un valor booleano se define mediante los equivalentes entre mayúsculas y minúsculas de los valores de la TrueString y FalseString campos, que son "True" y "False", respectivamente. En otras palabras, las cadenas únicas que se analizan correctamente son "True", "False", "true", "false" o algún equivalente de mayúsculas y minúsculas mezcladas. No se puede analizar correctamente cadenas numéricas como "0" o "1". No se consideran caracteres de espacio en blanco iniciales o finales al realizar la comparación de cadenas.

En el ejemplo siguiente se usa el Parse y TryParse métodos para analizar un número de cadenas. Tenga en cuenta que sólo los equivalentes entre mayúsculas y minúsculas de "True" y "False" se pueden analizar correctamente.

using System;

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

Si 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. "0" se convierte en false, y la representación de cadena de cualquier valor distinto de cero se convierte en true. Si no está programando en Visual Basic, debe convertir la cadena numérica en un número antes de convertir un valor booleano. En el ejemplo siguiente se ilustra esto mediante la conversión de una matriz de enteros para valores booleanos.

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

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 igual a un valor especificado. Normalmente, para comparar dos variables booleanas, se llama el Equals método o usar el operador de igualdad de su lenguaje.

Sin embargo, cuando desea comparar una variable booleana con el valor literal booleano true o false, no es necesario hacer una comparación explícita, dado que el resultado de evaluar un valor booleano es ese valor booleano. Por ejemplo, las expresiones

if (booleanValue) {

y

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.

son equivalentes, pero el segundo es más compacto. Sin embargo, ambas técnicas ofrecen un rendimiento comparable.

Un valor booleano ocupa un byte de memoria, como C# muestra el ejemplo siguiente. El ejemplo debe compilarse con la /unsafe cambiar.

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. Representa un valor de 1 true; el valor 0 representa false.

System_CAPS_warningAdvertencia

Puede usar el System.Collections.Specialized.BitVector32 estructura para trabajar con conjuntos de valores booleanos.

Puede convertir un valor booleano en su representación binaria mediante una llamada a la BitConverter.GetBytes(Boolean) método. El método devuelve una matriz de bytes con un único elemento. Para restaurar un valor booleano de su representación binaria, puede llamar a la BitConverter.ToBoolean(Byte[], Int32) método.

El ejemplo siguiente se llama el BitConverter.GetBytes método para convertir un valor booleano en 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.

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

Esta sección muestra los valores booleanos cómo se utilizan en las aplicaciones. La primera sección describe su uso como una marca. La segunda muestra su uso para las operaciones aritméticas.

Las variables booleanas se usan normalmente como marcas, para indicar la presencia o ausencia de alguna condición. Por ejemplo, en la String.Compare(String, String, Boolean) /método siguiente, el parámetro final, 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). A continuación, se puede evaluar el valor de la marca en una instrucción condicional.

En el ejemplo siguiente se usa una aplicación de consola simple para ilustrar el uso de las variables booleanas como marcas. 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 habilitan la salida se deben enviar a un archivo especificado y a la consola (el /b cambiar). La aplicación define una marca con el nombre isRedirected para indicar si es de salida para enviarse a un archivo y una marca con el nombre isBoth para indicar que se debe enviar la salida a la consola.

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");
   }
}

A veces se utiliza un valor booleano para indicar la presencia de una condición que desencadena un cálculo matemático. Por ejemplo, un hasShippingCharge variable puede actuar como una marca para indicar si desea agregar los gastos de envío a una cantidad de factura.

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 usarlo en la operación matemática. En su lugar, puede usar lógica condicional.

En el ejemplo siguiente se calcula un importe que consta de un subtotal, gastos de envío y un cargo de servicio opcional. El hasServiceCharge variable determina si se aplica el cargo por servicios. En lugar de convertir hasServiceCharge a un valor numérico y multiplicar por la cantidad de los gastos de servicio, en el ejemplo se usa lógica condicional para agregar el cargo de servicio si es aplicable.

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.

Aunque referencias de tipos de datos base para COM es generalmente sencilla, la Boolean tipo de datos es una excepción. Puede aplicar el MarshalAsAttribute atributo para serializar el Boolean tipo a cualquiera de las representaciones siguientes:

Tipo de enumeración

Formato no administrado

UnmanagedType.Bool

Un valor entero de 4 bytes, donde cualquier valor distinto de cero representa true y 0 representa false. Este es el formato predeterminado de un Boolean campo en una estructura y un Boolean llamadas de invocación de parámetro en la plataforma.

UnmanagedType.U1

Un valor entero de 1 byte, que representa la versión 1 true y 0 representa false.

UnmanagedType.VariantBool

Un valor entero de 2 bytes, que representa -1 true y 0 representa false. Este es el formato predeterminado de un Boolean parámetro en las llamadas de interoperabilidad COM.

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Todos los miembros de este tipo son seguros para subprocesos. Los miembros que aparecen modificar el estado de instancia realmente devuelven una nueva instancia inicializada con el nuevo valor. 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.

Volver al principio
Mostrar: