Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Boolean (Estructura)

Representa (true o false) un valor booleano.

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

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

El tipo Boolean expone los siguientes miembros.

  NombreDescripción
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsCompareTo(Boolean)Compara esta instancia con el objeto Boolean especificado y devuelve un entero que indica la relación entre ambos.
Método públicoCompatible con XNA FrameworkCompareTo(Object)Compara esta instancia con un objeto especificado y devuelve un entero que indica la relación entre ambos.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEquals(Boolean)Devuelve un valor que indica si esta instancia equivale a un objeto Boolean especificado.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEquals(Object)Devuelve un valor que indica si esta instancia equivale a un objeto especificado. (Invalida a ValueType.Equals(Object)).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetHashCodeDevuelve el código hash de esta instancia. (Invalida a ValueType.GetHashCode()).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetType Obtiene el Typede la instancia actual. (Se hereda de Object).
Método públicoCompatible con XNA FrameworkGetTypeCodeDevuelve el TypeCode para el tipo de valor Boolean.
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsParseConvierte la representación de cadena especificada de un valor lógico en su Boolean equivalente o genera una excepción si la cadena no es igual al valor de Boolean.TrueString o Boolean.FalseString.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToString()Convierte el valor de esta instancia en la representación de cadena equivalente ("True" o "False"). (Invalida a ValueType.ToString()).
Método públicoCompatible con XNA FrameworkToString(IFormatProvider)Convierte el valor de esta instancia en la representación de cadena equivalente ("True" o "False").
Método públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsTryParseIntenta 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.
Arriba

  NombreDescripción
Campo públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsFalseStringRepresenta el valor booleano false como una cadena. Este campo es de sólo lectura.
Campo públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsTrueStringRepresenta el valor booleano true como una cadena. Este campo es de sólo lectura.
Arriba

  NombreDescripción
Implementación explícita de interfacesMétodo privadoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsIComparable.CompareToInfraestructura. Compara la instancia actual con otro objeto del mismo tipo y devuelve un entero que indica si la posición de la instancia actual es anterior, posterior o igual que la del otro objeto en el criterio de ordenación.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToBooleanInfraestructura. Para obtener una descripción de este miembro, vea el método IConvertible.ToBoolean.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToByteInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToByte.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToCharInfraestructura. No se admite esta conversión. Cualquier intento de utilizar este método produce una excepción InvalidCastException.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDateTimeInfraestructura. No se admite esta conversión. Cualquier intento de utilizar este método produce una excepción InvalidCastException.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDecimalInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToDecimal.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDoubleInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToDouble.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt16Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToInt16.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt32Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToInt32.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt64Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToInt64.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToSByteInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToSByte.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToSingleInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToSingle.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToTypeInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToType.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt16Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToUInt16.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt32Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToUInt32.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt64Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToUInt64.
Arriba

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

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

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

Valores booleanos de formato
El convertir entre valores booleanos
Valores booleanos de análisis
Comparar valores booleanos
Trabajar con valores booleanos como valores binarios
Realizar operaciones con valores booleanos

Valores booleanos de formato

La representación de cadena de Boolean es “True” para un valor de true o “False” para un valor de false . Campos de solo lectura de FalseString define a la representación de cadena de un valor de BooleanTrueString y.

Utilice el método de ToString para convertir valores booleanos en cadenas. La estructura booleana incluye dos sobrecargas de ToString : el método sin parámetros de ToString() y el método de ToString(IFormatProvider) , que incluye un parámetro que controla el formato. Sin embargo, dado que se omite este parámetro, las dos cadenas idénticas de producción de las sobrecargas. El método de ToString(IFormatProvider) no admite el formato cultura- confidencial.

El ejemplo siguiente muestra formato con el método de ToString . Observe que el ejemplo utiliza la característica de formato compuesto , por lo que el método de ToString se llama implícitamente.


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 la estructura de Boolean sólo puede tener dos valores, es fácil agregar formato personalizado. Para el formato personalizado simple en el que otros literales de cadena se sustituyen para “True” y “False”, puede utilizar cualquier característica condicional de evaluación compatible con el lenguaje, como operador condicional en C# o Si operador en Visual Basic. El ejemplo siguiente se utiliza esta técnica para dar formato a los valores de Boolean 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 personalizadas más complejas de formato, incluido el formato cultura- confidencial, puede llamar al método de String.Format(IFormatProvider, String, Object[]) y proporcionar una implementación de ICustomFormatter . El ejemplo siguiente implementa las interfaces de ICustomFormatter y de IFormatProvider para proporcionar cadenas booleanas cultura- confidenciales para las referencias culturales inglés (Estados Unidos), las francés (Francia), y rusas (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': верно


Opcionalmente, puede utilizar archivos de recursos para definir cadenas booleanas cultura- concretas.

El convertir entre valores booleanos

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

Todas las conversiones de entero o números de punto flotante a los valores booleanos convierten valores distintos a true y valores cero a false. Esto se muestra en el siguiente ejemplo mediante llamadas a las sobrecargas seleccionadas de la clase de Convert.ToBoolean .


using System;

public class Example
{
   public static void Main()
   {
      Byte byteValue = 12;
      Console.WriteLine(Convert.ToBoolean(byteValue));
      Byte byteValue2 = 0;
      Console.WriteLine(Convert.ToBoolean(byteValue2));
      int intValue = -16345;
      Console.WriteLine(Convert.ToBoolean(intValue));
      long longValue = 945;
      Console.WriteLine(Convert.ToBoolean(longValue));
      SByte sbyteValue = -12;
      Console.WriteLine(Convert.ToBoolean(sbyteValue));
      double dblValue = 0;
      Console.WriteLine(Convert.ToBoolean(dblValue));
      float sngValue = .0001f;
      Console.WriteLine(Convert.ToBoolean(sngValue));
   }
}
// The example displays the following output:
//       True
//       False
//       True
//       True
//       True
//       False
//       True


Al convertir de valores de punto flotante a los 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 muestra en el ejemplo siguiente, en el que una variable de Double cuyo valor debe ser cero se convierte en un valor booleano. Como el ejemplo, el resultado es true porque las adiciones repetidas de 0,2 han dado lugar a una pérdida de precisión.

Al convertir de boolean a los valores numéricos, los métodos de conversión de la clase de Convert convierten true en 1 y false a 0. Sin embargo, las funciones de conversión de Visual Basic convierten true a 255 (para las conversiones a los valores de Byte ) o -1 (para el resto de las conversiones numéricas). El ejemplo siguiente se convierte true a los valores numéricos mediante un método de Convert , y, en el caso del ejemplo de Visual Basic, con el propio operador de conversión del lenguaje Visual Basic.


using System;

public class Example
{
   public static void Main()
   {
      bool flag = true;

      byte byteValue;   
      byteValue = Convert.ToByte(flag);
      Console.WriteLine("{0} -> {1}", flag, byteValue);         

      sbyte sbyteValue;
      sbyteValue = Convert.ToSByte(flag);
      Console.WriteLine("{0} -> {1}", flag, sbyteValue);         

      double dblValue;
      dblValue = Convert.ToDouble(flag);
      Console.WriteLine("{0} -> {1}", flag, dblValue);         

      int intValue;
      intValue = Convert.ToInt32(flag);
      Console.WriteLine("{0} -> {1}", flag, intValue);         
   }
}
// The example displays the following output:
//       True -> 1
//       True -> 1
//       True -> 1
//       True -> 1


Para las conversiones de Boolean a los valores de cadena, vea la sección de Valores booleanos de formato . Para las conversiones de cadenas a los valores de Boolean , vea la sección de Valores booleanos de análisis .

Valores booleanos de análisis

La estructura de Boolean incluye dos métodos, Parse y TryParseestáticos de análisis, que convierten una cadena en un valor booleano. Equivalentes sin distinción entre mayúsculas y minúsculas de los valores de los campos de TrueString define en la representación de cadena de un valor booleano y de FalseString , que son “True” y “False”, respectivamente. Es decir las únicas cadenas que analizan correctamente son “true”, “False”, “true”, “false”, o algún equivalente de mezclar- caso. No se puede analizar correctamente las cadenas numéricas como “0 " o “1 ". Los caracteres de espacio en blanco iniciales o finales no se consideran al realizar la comparación de cadenas.

El ejemplo siguiente utiliza los métodos de Parse y de TryParse para analizar varias cadenas. Observe que solo equivalentes sin distinción 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 utilizar la función de CBool para convertir la representación de cadena de un número a 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 convertirlo en un valor booleano. Esto se muestra en el siguiente ejemplo convertir una matriz de enteros a los 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


Comparar valores booleanos

Dado que los valores booleanos son true o false, hay poca razón para llamar explícitamente al método de CompareTo , que indica si una instancia es mayor que, menor que, o igual que un valor especificado. Normalmente, comparar dos variables boolean, llama al método de Equals o utiliza el operador de igualdad del lenguaje.

Sin embargo, si desea comparar una variable booleana con el valor booleano true o false, no es necesario realizar una comparación explícita, porque 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.


equivalente, pero el segundo es más compacto. Sin embargo, ambas técnicas proporcionan un rendimiento comparable.

Trabajar con valores booleanos como valores binarios

Un valor booleano ocupa un byte de memoria. El bit de orden inferior de byte se utiliza para representar el valor. El valor 1 representa true; el valor 0 representa false.

Nota de precauciónPrecaución

Puede utilizar la estructura de System.Collections.Specialized.BitVector32 para trabajar con conjuntos de valores booleanos.

Puede convertir un valor boolean en su representación binaria llamando al método de BitConverter.GetBytes(Boolean) . El método devuelve una matriz de bytes con un solo elemento. Para restablecer el valor booleano de la representación binaria, puede llamar al método de BitConverter.ToBoolean(Byte[], Int32) .

El ejemplo siguiente llama al método de BitConverter.GetBytes para convertir un valor boolean en su representación binaria y muestra los bits individuales de valor, y después llama al método de BitConverter.ToBoolean para restablecer 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


Realizar operaciones con valores booleanos

Esta sección muestra cómo los valores booleanos se utilizan en aplicaciones. La primera sección explica su uso como marcador. El segundo muestra su uso para las operaciones aritméticas.

a28wyd50.collapse_all(es-es,VS.110).gifValores booleanos como marcadores

Variables booleanas se utilizan con frecuencia como marcadores, elija la presencia o ausencia de alguna condición. Por ejemplo, en el método de String.Compare(String, String, Boolean) , el parámetro final, ignoreCase, es una marca que indica si la comparación de dos cadenas no distingue entre mayúsculas y minúsculas (ignoreCase es true) o con distinción entre mayúsculas y minúsculas (ignoreCase es false). El valor del marcador se puede evaluar en una instrucción condicional.

El ejemplo siguiente utiliza una sencilla aplicación de consola para mostrar el uso de variables booleanas como marcadores. La aplicación acepta parámetros de línea de comandos que permiten la salida que se redirigirá a un archivo especificado (el modificador /f ), y que habilitan la salida se envía a un archivo especificado y en la consola (el modificador /b ). La aplicación define un marcador denominado isRedirected para indicar si la salida debe enviar a un archivo, y un marcador denominado isBoth para indicar que la salida debe ser enviada 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");
   }
}


a28wyd50.collapse_all(es-es,VS.110).gifValores booleanos y operaciones aritméticas

Un valor booleano se utiliza a veces para indicar la presencia de una condición que desencadena un cálculo matemático. Por ejemplo, una variable de hasShippingCharge podría actuar como marcador indicar si agregar cargas de envío a una cantidad de factura.

Dado que una operación con un valor de false no tiene ningún efecto en el resultado de una operación, no es necesario convertir el tipo booleano en un valor entero para utilizar en la operación matemática. En su lugar, puede utilizar lógica condicional.

El siguiente ejemplo se calcula una cantidad formado por un subtotal, gastos de envio, y un gasto por servicio opcional. La variable de hasServiceCharge determina si se aplica el gasto por servicio. En lugar de convertir hasServiceCharge a un valor numérico y de multiplicarlo por el importe del gasto por servicio, el ejemplo utiliza lógica condicional para agregar el importe del gasto por 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.


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros de este tipo son seguros para la ejecución de subprocesos. Los miembros que aparecen para modificar el estado de la instancia devuelven una nueva instancia inicializada con el nuevo valor. Al igual que con cualquier otro tipo, la lectura y escritura en una variable compartida que contiene una instancia de este tipo deben protegerse mediante un bloqueo para garantizar la seguridad para subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft