Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Estrutura Boolean

Representatrue (ou) falseum valor booliano.

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

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

O tipo Boolean expõe os membros a seguir.

  NomeDescrição
Método públicoCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreCompareTo(Boolean)Compara esta instância em um objeto especificado de Boolean e retorna um inteiro que indica sua relação com outra.
Método públicoCompatível com o XNA FrameworkCompareTo(Object)Compara esta instância em um objeto especificado e retorna um inteiro que indica sua relação com outra.
Método públicoCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreEquals(Boolean)Retorna um valor que indica se esta instância é igual ao objeto especificado de Boolean .
Método públicoCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreEquals(Object)Retorna um valor que indica se essa instância é igual a um objeto especificado. (Substitui ValueType.Equals(Object).)
Método públicoCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreGetHashCode Retorna o hash code para essa instância. (Substitui ValueType.GetHashCode().)
Método públicoCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreGetType Obtém o Type da instância atual. (Herdado de Object.)
Método públicoCompatível com o XNA FrameworkGetTypeCodeRetorna TypeCode para o tipo de valor Boolean.
Método públicoMembro estáticoCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreParseConverte a representação de cadeia de caracteres especificada de um valor lógico para seu equivalente de Boolean , ou lançará uma exceção se a cadeia de caracteres não é igual ao valor de Boolean.TrueString ou de Boolean.FalseString.
Método públicoCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreToString()Converte o valor dessa instância na representação da cadeia de caracteres equivalente ("True" ou "False"). (Substitui ValueType.ToString().)
Método públicoCompatível com o XNA FrameworkToString(IFormatProvider)Converte o valor dessa instância na representação da cadeia de caracteres equivalente ("True" ou "False").
Método públicoMembro estáticoCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreTryParseTentará converter a representação de cadeia de caracteres especificada de um valor lógico para seu equivalente de Boolean . Um valor de retorno indica se a conversão foi bem-sucedida ou falhou.
Superior

  NomeDescrição
Campo públicoMembro estáticoCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreFalseStringRepresenta o valor booliano false como uma cadeia de caracteres. Este campo é somente leitura.
Campo públicoMembro estáticoCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreTrueStringRepresenta o valor booliano true como uma cadeia de caracteres. Este campo é somente leitura.
Superior

  NomeDescrição
Implementação explícita da interfaceMétodo particularCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreIComparable.CompareToInfraestrutura. Compara a instância atual com outro objeto do mesmo tipo e retorna um inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição da ordem de classificação do outro objeto.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToBooleanInfraestrutura. Para obter uma descrição desse membro, consulte IConvertible.ToBoolean.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToByteInfraestrutura. Para obter uma descrição desse membro, consulte IConvertible.ToByte.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToCharInfraestrutura. Esta conversão não é suportada. A tentativa de usar esse método lança um InvalidCastException.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToDateTimeInfraestrutura. Esta conversão não é suportada. A tentativa de usar esse método lança um InvalidCastException.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToDecimalInfraestrutura. Para obter uma descrição desse membro, consulte. IConvertible.ToDecimal.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToDoubleInfraestrutura. Para obter uma descrição desse membro, consulte. IConvertible.ToDouble.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToInt16Infraestrutura. Para obter uma descrição desse membro, consulte IConvertible.ToInt16.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToInt32Infraestrutura. Para obter uma descrição desse membro, consulte IConvertible.ToInt32.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToInt64Infraestrutura. Para obter uma descrição desse membro, consulte IConvertible.ToInt64.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToSByteInfraestrutura. Para obter uma descrição desse membro, consulte IConvertible.ToSByte.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToSingleInfraestrutura. Para obter uma descrição desse membro, consulte. IConvertible.ToSingle.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToTypeInfraestrutura. Para obter uma descrição desse membro, consulte IConvertible.ToType.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToUInt16Infraestrutura. Para obter uma descrição desse membro, consulte IConvertible.ToUInt16.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToUInt32Infraestrutura. Para obter uma descrição desse membro, consulte IConvertible.ToUInt32.
Implementação explícita da interfaceMétodo particularCompatível com o XNA FrameworkIConvertible.ToUInt64Infraestrutura. Para obter uma descrição desse membro, consulte IConvertible.ToUInt64.
Superior

Uma instância de Boolean pode ter um dos seguintes valores: true, ou false.

A estrutura de Boolean fornece métodos que dão suporte às seguintes tarefas:

  • Convertendo valores boolianos em cadeias de caracteres: ToString

  • Cadeias de caracteres de análise para convertê-los os valores booliano: Parse e TryParse

  • Comparando valores: CompareTo e Equals

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

Valores boolianos de formatação
A conversão para e de valores boolianos
Valores boolianos de análise
Comparando valores boolianos
Trabalhando com o Boolianos como valores binários
Executando operações com os valores boolianos

Valores boolianos de formatação

A representação de cadeia de caracteres de Boolean é ou “true” para um valor de true ou “false” para um valor de false . A representação de cadeia de caracteres de um valor de Boolean é definida por TrueString e pelos campos somente leitura de FalseString .

Você usa o método de ToString para converter valores boolianos em cadeias de caracteres. A estrutura booliano inclui duas sobrecargas de ToString : o método sem parâmetros de ToString() e o método de ToString(IFormatProvider) , que inclui um parâmetro que a formatação dos controles. No entanto, como esse parâmetro é ignorado, as duas cadeias de caracteres idênticas do produto das sobrecargas. O método de ToString(IFormatProvider) não da suporte à formatação cultura acentos.

O exemplo a seguir ilustra a formatação com o método de ToString . Observe que o exemplo usa o recurso de formatação composta , assim o método de ToString é 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


Como a estrutura de Boolean pode ter apenas dois valores, é fácil adicionar a formatação personalizada. Para formatação personalizada simples em que outras cadeias literais são substituídas para “verdadeiro” e “falso”, você pode usar qualquer recurso condicional de avaliação suporte pelo idioma, como operador condicional em C# ou Se operador no Visual Basic. O exemplo a seguir usa essa técnica formatar valores de Boolean como “Sim” e “não” em vez de “verdadeiro” e “falso”.


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 personalizadas mais complexas de formatação, inclusive a formatação cultura acentos, você pode chamar o método de String.Format(IFormatProvider, String, Object[]) e fornecer uma implementação de ICustomFormatter . O exemplo a seguir implementa ICustomFormatter e IFormatProvider interfaces para fornecer cadeias de caracteres boolianos sensíveis a cultura para as culturas inglês (Estados Unidos), o francês (França), e o 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 para definir cadeias de caracteres boolianos cultura específicas.

A conversão para e de valores boolianos

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

Todas as conversões de integral ou os números de pontos flutuantes como valores boolianos convertem valores diferentes de zero a true e valores de zero a false. O exemplo a seguir ilustra isto chamando sobrecargas selecionadas da classe 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


A conversão dos valores de ponto flutuante os valores booliano, os métodos de conversão executa uma comparação exata com zeros. Se o valor de ponto flutuante perder precisão, o resultado pode ser inesperada. Isso é ilustrado no seguinte exemplo, no qual uma variável de Double cujo valor será nulo será convertido em um valor booliano. Como o exemplo a seguir mostra, o resultado será true como as adições repetidas de 0,2 resultaram em uma perda de precisão.

Ao converter de booliano para valores numéricos, os métodos de conversão da classe de Convert convertem true a 1 e false a 0. Porém, as funções de conversão do Visual Basic convertem true a 255 (para conversões com os valores de Byte ) ou -1 (para todas as conversões numéricas outros). O exemplo a seguir converte true para valores numéricos usando um método de Convert , e, no caso de exemplo do Visual Basic, usando operador de conversão de linguagem Visual Basic próprio.


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

Valores boolianos de análise

A estrutura de Boolean inclui dois métodos, Parse e TryParseestáticos de análise, que converte uma cadeia de caracteres em um valor booliano. A representação de cadeia de caracteres de um valor booliano é definida pelos equivalentes sem diferenciação de maiúsculas e minúsculas dos valores dos campos de TrueString e de FalseString , que são “verdadeiro” e “falso”, respectivamente. Ou seja as únicas cadeias de caracteres que analisam com êxito são “verdadeiro”, “falso”, “verdadeiro”, “falso”, ou qualquer equivalente de maiúsculas e minúsculas. Você não pode ser analisada com sucesso cadeias de caracteres numéricas como “0 " ou “1 ". Os 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 os métodos de Parse e de TryParse para analisar um número de cadeias de caracteres. Observe que somente os equivalentes sem diferenciação de maiúsculas e minúsculas “verdadeiro” e “falso” com êxito podem ser analisados.


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 a função de CBool para converter a representação de cadeia de caracteres de um número para um valor booliano. “0 " são convertidos 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 a um número antes de convertê-los em um booliano. O exemplo a seguir ilustra esse convertendo uma matriz de inteiros os valores booliano.


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


Comparando valores boolianos

Como valores boolianos são true ou false, não há muita motivo chamar explicitamente o método de CompareTo , que indicam se uma instância é maior que, menor que, ou igual a um valor especificado. Normalmente, para comparar duas variáveis boolianas, chame o método de Equals ou usa o operador de igualdade do idioma.

No entanto, quando você deseja comparar uma variável booliana com o valor booliano true literal ou false, não é necessário fazer uma comparação explícita, como o resultado da avaliação de um valor booliano é aquele 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.


é equivalente, mas o segundo é mais compact. No entanto, ambas as técnicas oferecem desempenho comparável.

Trabalhando com o Boolianos como valores binários

Um valor booliano ocupa um byte da memória. O bit de baixo ordem de byte é usado para representar o valor. Um valor de 1 representa true; um valor de 0 representa false.

Observação de cuidadoCuidado

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

Você pode converter um valor booliano em sua representação binária chamando o método de BitConverter.GetBytes(Boolean) . 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 método de BitConverter.ToBoolean(Byte[], Int32) .

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


Executando operações com os valores boolianos

Esta seção ilustra como valores boolianos são usados em aplicativos. A primeira seção discute o uso como um sinalizador. O segundo ilustra seu uso em operações aritméticas.

a28wyd50.collapse_all(pt-br,VS.110).gifValores boolianos como sinalizadores

As variáveis booleanas são usados com mais frequência como sinalizadores, sinalizar a presença ou a ausência de alguma condição. Por exemplo, no método de String.Compare(String, String, Boolean) , o parâmetro final, ignoreCase, é um sinalizador que indica se a comparação de duas cadeias de caracteres não diferencia maiúsculas e minúsculas (ignoreCase é true) ou com diferenciação de maiúsculas e minúsculas (ignoreCase é false). O valor do sinalizador 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 habilitam a saída a ser redirecionadas para um arquivo especificado (a opção de /f ), e habilitam a saída a ser enviado a um arquivo especificado e no console (a opção de /b ). O aplicativo define um sinalizador nomeada isRedirected para indicar se a saída deve ser enviadas a um arquivo, e um sinalizador nomeada isBoth para indicar que a saída deve ser enviada ao 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");
   }
}


a28wyd50.collapse_all(pt-br,VS.110).gifBoolianos e operações aritméticas

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

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

O exemplo a seguir calcula uma quantidade que consiste em um subtotal, em uma taxa de envio, e uma taxa de serviço opcional. A variável de hasServiceCharge determina se a taxa de serviço será aplicada. Em vez de converter hasServiceCharge a um valor numérico e de multiplicá-lo pela quantidade proporcional de serviço, a lógica condicional de exemplo usa para adicionar a quantidade proporcional de 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.


.NET Framework

Com suporte em: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Com suporte em: 4, 3.5 SP1

Biblioteca de Classes Portátil

Com suporte em: Biblioteca de Classes Portátil

.NET para aplicativos da Windows Store

Com suporte em: Windows 8

.NET para aplicativos do Windows Phone

Com suporte em: 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 (Função Server Core sem suporte), Windows Server 2008 R2 (Função Server Core com suporte com o SP1 ou posterior, Itanium sem suporte)

O .NET Framework não oferece suporte a todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte Requisitos do sistema do .NET Framework.

Todos os membros desse tipo são segmento seguro. Os membros que aparecem para modificar o estado da instância, na verdade, retornam uma nova instância inicializada com o novo valor. Como com qualquer outro tipo, leitura e gravação a uma variável compartilhada que contém uma instância desse tipo deve ser protegida por um bloqueio para garantir segurança de segmentos.

Contribuições da comunidade

ADICIONAR
A Microsoft está realizando uma pesquisa online para saber sua opinião sobre o site do MSDN. Se você optar por participar, a pesquisa online lhe será apresentada quando você sair do site do MSDN.

Deseja participar?
Mostrar:
© 2014 Microsoft