Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Estrutura Boolean

 

Representa um valor booliano (true ou false).

Namespace:   System
Assembly:  mscorlib (em mscorlib.dll)

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

NomeDescrição
System_CAPS_pubmethodCompareTo(Boolean)

Compara essa instância com um objeto Boolean especificado e retorna um inteiro que indica a relação entre eles.

System_CAPS_pubmethodCompareTo(Object)

Compara essa instância com um objeto especificado e retorna um inteiro que indica a relação entre eles.

System_CAPS_pubmethodEquals(Boolean)

Retorna um valor que indica se essa instância é igual a um objeto Boolean especificado.

System_CAPS_pubmethodEquals(Object)

Retorna um valor que indica se essa instância é igual a um objeto especificado.(Substitui o ValueType.Equals(Object).)

System_CAPS_pubmethodGetHashCode()

Retorna o hash code para essa instância. (Substitui o ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtém o Type da instância atual.(Herdado de Object.)

System_CAPS_pubmethodGetTypeCode()

Retorna o código de tipo para o Boolean tipo de valor.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Converte a representação de cadeia de caracteres especificada de um valor lógico em seu Boolean equivalente.

System_CAPS_pubmethodToString()

Converte o valor dessa instância na representação da cadeia de caracteres equivalente ("True" ou "False").(Substitui o ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Converte o valor dessa instância na representação da cadeia de caracteres equivalente ("True" ou "False").

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Boolean)

Tenta converter a representação de cadeia de caracteres especificada de um valor lógico em seu Boolean equivalente. Um valor de retorno indica se a conversão foi bem-sucedida ou falhou.

NomeDescrição
System_CAPS_pubfieldSystem_CAPS_staticFalseString

Representa o valor booliano false como uma cadeia de caracteres. Este campo é somente leitura.

System_CAPS_pubfieldSystem_CAPS_staticTrueString

Representa o valor booliano true como uma cadeia de caracteres. Este campo é somente leitura.

NomeDescrição
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToDecimal...

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToDouble...

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToSingle...

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToUInt64.

Um Boolean instância pode ter um dos dois valores: true, ou false.

O Boolean estrutura fornece métodos que oferecem suporte as seguintes tarefas:

  • Convertendo valores booleanos em cadeias de caracteres:ToString

  • Analisando cadeias de caracteres para convertê-los em valores booleanos: Parse eTryParse

  • Comparando valores: CompareTo eEquals

As seções a seguir explicam essas tarefas e outros detalhes de uso:

Formatando valores booleanos
Converter para e de valores boolianos
Análise de valores Boolean
Comparando valores booleanos
Trabalhando com valores booleanos como valores binários
Executar operações com valores booleanos
Valores booleanos e interoperabilidade

A representação de cadeia de caracteres de um Boolean é "True" para um true valor ou "False" para um false valor. A representação de cadeia de caracteres de um Boolean valor é definido pela somente leitura TrueString e FalseString campos.

Você usa o ToString método para converter valores boolianos para cadeias de caracteres. A estrutura de booliana inclui dois ToString sobrecargas: sem o parâmetro ToString() método e o ToString(IFormatProvider) método, que inclui um parâmetro que controla a formatação. No entanto, porque esse parâmetro é ignorado, duas sobrecargas produzem cadeias de caracteres idênticas. O ToString(IFormatProvider) método não oferece suporte para formatação sensíveis à cultura.

O exemplo a seguir ilustra a formatação com o ToString método. Observe que o exemplo usa o formatação composta recurso, portanto, o ToString método é chamado implicitamente.

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

Porque o Boolean estrutura pode ter apenas dois valores, é fácil adicionar formatação personalizada. Para simples formatação personalizada na qual outra cadeia de caracteres literais são substituídos por "True" e "False", você pode usar qualquer recurso de avaliação condicional suportado por seu idioma, como o operador condicional em c# ou o se operador no Visual Basic. O exemplo a seguir usa essa técnica para formatar Boolean valores como "Sim" e "Não" em vez de "True" e "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 operações formatação personalizadas mais complexas, incluindo formatação sensíveis à cultura, você pode chamar o String.Format(IFormatProvider, String, Object[]) método e fornecer um ICustomFormatter implementação. O exemplo a seguir implementa a ICustomFormatter e IFormatProvider interfaces para fornecer cadeias de caracteres Boolianas sensíveis à cultura para o inglês (Estados Unidos), francês (França) e culturas russo (Rússia).

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, você pode usar arquivos de recurso defina cadeias de caracteres Boolianas específicos de cultura.

O Boolean estrutura implementa o IConvertible interface. Como resultado, você pode usar o Convert classe para realizar conversões entre um Boolean valor e qualquer outro tipo primitivo no .NET Framework, ou você podem chamar o Boolean implementações explícitas da estrutura. No entanto, conversões entre um Boolean e os seguintes tipos não têm suporte para os métodos de conversão correspondentes lançam um InvalidCastException exceção:

Todas as conversões de números inteiros ou de ponto flutuantes para valores booleanos convertem valores diferentes de zero para true e valores zero para false. O exemplo a seguir ilustra isso chamando sobrecargas selecionadas do Convert.ToBoolean classe.

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

Ao converter de valores de ponto flutuante em valores booleanos, os métodos de conversão realizam uma comparação exata com zero. Se o valor de ponto flutuante perdeu a precisão, o resultado pode ser inesperado. Isso é ilustrado no exemplo a seguir, no qual um Double variável cujo valor deve ser zero é convertido em um valor booleano. Como mostra o exemplo, o resultado é true porque repetido adições de 0,2 resultaram em perda de precisão.

Ao converter de booliano em valores numéricos, os métodos de conversão do Convert classe convert true como 1 e false como 0. No entanto, funções de conversão do Visual Basic convertem true a qualquer 255 (para conversões em Byte valores) ou -1 (para todas as outras conversões numéricas). O exemplo a seguir converte true para valores numéricos, usando um Convert método e, no caso do exemplo do Visual Basic, usando o operador de conversão do Visual Basic do idioma próprios.

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 conversões de Boolean valores de cadeia de caracteres, consulte a formatação valores booleanos seção. Para conversões de cadeias de caracteres para Boolean valores, consulte o valores booleanos análise seção.

A Boolean estrutura inclui dois métodos de análise estáticos, Parse e TryParse, que converter uma cadeia de caracteres em um valor booleano. A representação de cadeia de caracteres de um valor booliano é definida pelos equivalentes de maiusculas e minúsculas dos valores da TrueString e FalseString campos, que são "True" e "Falso", respectivamente. Em outras palavras, somente cadeias de caracteres que são analisados com êxito são "True", "False", "true", "false" ou algum equivalente em maiusculas. Você não pode analisar com sucesso cadeias de caracteres numéricas, como "0" ou "1". Caracteres de espaço em branco à esquerda ou à direita não são considerados ao executar a comparação de cadeia de caracteres.

O exemplo a seguir usa o Parse e TryParse métodos para analisar um número de cadeias de caracteres. Observe que somente os equivalentes de maiusculas e minúsculas de "True" e "False" podem ser analisados com êxito.

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'

Se você estiver programando no Visual Basic, você pode usar o CBool function para converter a representação de cadeia de caracteres de um número para um valor booliano. "0" é convertido em false, e a representação de cadeia de caracteres de qualquer valor diferente de zero é convertida em true. Se você não estiver programando no Visual Basic, você deve converter a cadeia de caracteres numérica para um número antes de convertê-lo para um valor booleano. O exemplo a seguir ilustra isso ao converter uma matriz de inteiros em 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

Porque valores boolianos são true ou false, há poucos motivos para chamar explicitamente o CompareTo método, que indica se uma instância é maior que, menor que, ou igual ao valor especificado. Normalmente, para comparar duas variáveis boolianos, que você chamar o Equals método ou use o operador de igualdade do idioma.

No entanto, quando você deseja comparar uma variável booleana com o valor booliano literal true ou false, não é necessário fazer uma comparação explícita, como o resultado da avaliação de um valor booliano é esse valor booliano. Por exemplo, as expressões

if (booleanValue) {

e

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.

são equivalentes, mas o segundo é mais compacto. No entanto, ambas as técnicas oferecem um desempenho comparável.

Um valor booliano ocupa um byte de memória, como c# exemplo a seguir. O exemplo deve ser compilado com o /unsafe alternar.

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

Bits de ordem inferior do byte é usada para representar seu valor. Representa um valor de 1 true; um valor de 0 representa false.

System_CAPS_warningAviso

Você pode usar o System.Collections.Specialized.BitVector32 estrutura para trabalhar com conjuntos de valores booleanos.

Você pode converter um valor booliano em sua representação binária chamando o BitConverter.GetBytes(Boolean) método. O método retorna uma matriz de bytes com um único elemento. Para restaurar um valor booliano de sua representação binária, você pode chamar o BitConverter.ToBoolean(Byte[], Int32) método.

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

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 seção ilustra como Boolean valores são usados em aplicativos. A primeira seção discute o uso como um sinalizador. O segundo ilustra seu uso para operações aritméticas.

Variáveis booleanas são mais comumente usados como sinalizadores, para indicar a presença ou ausência de algumas condições. Por exemplo, o String.Compare(String, String, Boolean) método, o parâmetro final, ignoreCase, um sinalizador que indica se a comparação de duas cadeias de caracteres diferencia maiusculas de minúsculas (ignoreCase é true) ou diferencia maiusculas de minúsculas (ignoreCase é false). O valor do sinalizador de, em seguida, pode ser avaliado em uma instrução condicional.

O exemplo a seguir usa um aplicativo de console simples para ilustrar o uso de variáveis Boolianas como sinalizadores. O aplicativo aceita parâmetros de linha de comando que permitem a saída a ser redirecionado para um arquivo especificado (o /f alternar), e que permitem a saída a ser enviada para um arquivo especificado e para o console (o /b alternar). O aplicativo define um sinalizador denominado isRedirected para indicar se será enviado para um arquivo de saída e um sinalizador denominado isBoth para indicar que a saída deve ser enviada para o 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");
   }
}

Um valor booliano, às vezes, é usado para indicar a presença de uma condição que dispara um cálculo matemático. Por exemplo, um hasShippingCharge variável pode servir como um sinalizador para indicar se deseja adicionar os encargos de remessa a um valor de fatura.

Porque uma operação com um false valor não tem nenhum efeito no resultado de uma operação, não é necessário converter o valor booliano para um valor inteiro a ser usado na operação matemática. Em vez disso, você pode usar lógica condicional.

O exemplo a seguir calcula um valor que consiste em um encargo de serviço opcional, um encargo de remessa e um subtotal. O hasServiceCharge variável determina se o custo de serviço é aplicado. Em vez de converter hasServiceCharge para um valor numérico e multiplicá-lo pela quantidade do custo de serviço, o exemplo usa lógica condicional para adicionar o valor de custo do serviço se for aplicável.

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.

Enquanto o marshaling de tipos de dados base COM é geralmente simples, o Boolean tipo de dados é uma exceção. Você pode aplicar o MarshalAsAttribute atributo para empacotar o Boolean tipo para qualquer uma das representações a seguir:

Tipo de enumeração

Formato não gerenciado

UnmanagedType.Bool

Um valor inteiro de 4 bytes, onde qualquer valor diferente de zero representa true e 0 representa false. Este é o formato padrão de um Boolean campo em uma estrutura e de um Boolean chamadas de invocação de parâmetro na plataforma.

UnmanagedType.U1

Um valor inteiro de 1 byte, em que 1 representa true e 0 representa false.

UnmanagedType.VariantBool

Um valor inteiro de 2 bytes, onde -1 representa true e 0 representa false. Este é o formato padrão de um Boolean parâmetro em chamadas de interoperabilidade COM.

Plataforma Universal do Windows
Disponível desde 8
.NET Framework
Disponível desde 1.1
Biblioteca de Classes Portátil
Com suporte no: plataformas portáteis do .NET
Silverlight
Disponível desde 2.0
Windows Phone Silverlight
Disponível desde 7.0
Windows Phone
Disponível desde 8.1

Todos os membros desse tipo são segmento seguro. Os membros que aparentam modificar efetivamente o estado retornam uma nova instância inicializada com o novo valor. Assim como acontece com qualquer outro tipo, a leitura e a gravação em uma variável compartilhada que contém uma instância desse tipo devem ser protegidas por um bloqueio para garantir thread-safe.

Retornar ao início
Mostrar: