# Boolean Struct

## Definition

Representa um valor booliano (`true` ou `false`).Represents a Boolean (`true` or `false`) value.

``public value class Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>``
``public value class Boolean : IComparable, IConvertible``
``public value class Boolean : IComparable, IComparable<bool>, IEquatable<bool>``
``public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>``
``````[System.Serializable]
public struct Boolean : IComparable, IConvertible``````
``````[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>``````
``public struct Boolean : IComparable, IComparable<bool>, IEquatable<bool>``
``````type bool = struct
interface IConvertible``````
``type bool = struct``
``````Public Structure Boolean
Implements IComparable, IComparable(Of Boolean), IConvertible, IEquatable(Of Boolean)``````
``````Public Structure Boolean
Implements IComparable, IConvertible``````
``````Public Structure Boolean
Implements IComparable, IComparable(Of Boolean), IEquatable(Of Boolean)``````
Inheritance
Boolean
Attributes
Implements

## Remarks

Uma instância de Boolean pode ter um destes dois valores: `true`ou `false`.A Boolean instance can have either of two values: `true`, or `false`.

A estrutura de Boolean fornece métodos que dão suporte às seguintes tarefas:The Boolean structure provides methods that support the following tasks:

As seções a seguir explicam essas tarefas e outros detalhes de uso:The following sections explain these tasks and other usage details:

### Formatando valores BoolianosFormatting Boolean values

A representação de cadeia de caracteres de um Boolean é "true" para um valor de `true` ou "false" para um valor `false`.The string representation of a Boolean is either "True" for a `true` value or "False" for a `false` value. A representação de cadeia de caracteres de um valor de Boolean é definida pelos campos TrueString somente leitura e FalseString.The string representation of a Boolean value is defined by the read-only TrueString and FalseString fields.

Você usa o método ToString para converter valores Boolianos em cadeias de caracteres.You use the ToString method to convert Boolean values to strings. A estrutura booliana inclui duas sobrecargas de ToString: o método ToString() sem parâmetros e o método ToString(IFormatProvider), que inclui um parâmetro que controla a formatação.The Boolean structure includes two ToString overloads: the parameterless ToString() method and the ToString(IFormatProvider) method, which includes a parameter that controls formatting. No entanto, como esse parâmetro é ignorado, as duas sobrecargas produzem cadeias de caracteres idênticas.However, because this parameter is ignored, the two overloads produce identical strings. O método ToString(IFormatProvider) não oferece suporte à formatação sensível à cultura.The ToString(IFormatProvider) method does not support culture-sensitive formatting.

O exemplo a seguir ilustra a formatação com o método ToString.The following example illustrates formatting with the ToString method. Observe que o exemplo usa o recurso de formatação composta , portanto, o método ToString é chamado implicitamente.Note that the example uses the composite formatting feature, so the ToString method is called implicitly.

``````using System;

public class Example
{
public static void Main()
{
bool raining = false;
bool busLate = true;

Console.WriteLine("It is raining: {0}", raining);
Console.WriteLine("The bus is late: {0}", busLate);
}
}
// The example displays the following output:
//       It is raining: False
//       The bus is late: True
``````
``````Module Example
Public Sub Main()
Dim raining As Boolean = False
Dim busLate As Boolean = True

Console.WriteLine("It is raining: {0}", raining)
Console.WriteLine("The bus is late: {0}", busLate)
End Sub
End Module
' The example displays the following output:
'       It is raining: False
'       The bus is late: True
``````

Como a estrutura de Boolean pode ter apenas dois valores, é fácil adicionar formatação personalizada.Because the Boolean structure can have only two values, it is easy to add custom formatting. Para formatação personalizada simples na qual outros literais de cadeia de caracteres são substituídos por "true" e "false", você pode usar qualquer recurso de avaliação condicional compatível com seu idioma, como o C# operador condicional no ou o operador If em Visual Basic.For simple custom formatting in which other string literals are substituted for "True" and "False", you can use any conditional evaluation feature supported by your language, such as the conditional operator in C# or the If operator in Visual Basic. O exemplo a seguir usa essa técnica para formatar valores de Boolean como "Sim" e "não" em vez de "verdadeiro" e "falso".The following example uses this technique to format Boolean values as "Yes" and "No" rather than "True" and "False".

``````using System;

public class Example
{
public static void Main()
{
bool raining = false;
bool busLate = true;

Console.WriteLine("It is raining: {0}",
raining ? "Yes" : "No");
Console.WriteLine("The bus is late: {0}",
busLate ? "Yes" : "No" );
}
}
// The example displays the following output:
//       It is raining: No
//       The bus is late: Yes
``````
``````Module Example
Public Sub Main()
Dim raining As Boolean = False
Dim busLate As Boolean = True

Console.WriteLine("It is raining: {0}",
If(raining, "Yes", "No"))
Console.WriteLine("The bus is late: {0}",
If(busLate, "Yes", "No"))
End Sub
End Module
' The example displays the following output:
'       It is raining: No
'       The bus is late: Yes
``````

Para operações de formatação personalizada mais complexas, incluindo a formatação sensível à cultura, você pode chamar o método String.Format(IFormatProvider, String, Object[]) e fornecer uma implementação de ICustomFormatter.For more complex custom formatting operations, including culture-sensitive formatting, you can call the String.Format(IFormatProvider, String, Object[]) method and provide an ICustomFormatter implementation. O exemplo a seguir implementa as interfaces ICustomFormatter e IFormatProvider para fornecer cadeias de caracteres booleanas sensíveis à cultura para as culturas inglês (Estados Unidos), francês (França) e russo (Rússia).The following example implements the ICustomFormatter and IFormatProvider interfaces to provide culture-sensitive Boolean strings for the English (United States), French (France), and Russian (Russia) cultures.

``````using System;
using System.Globalization;

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

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

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

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

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

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

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

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

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

Module Example
Public Sub Main()
Dim cultureNames() As String = { "", "en-US", "fr-FR", "ru-RU" }
For Each cultureName In cultureNames
Dim value As Boolean = True
Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
Dim formatter As New BooleanFormatter(culture)

Dim result As String = String.Format(formatter, "Value for '{0}': {1}", culture.Name, value)
Console.WriteLine(result)
Next
End Sub
End Module

Public Class BooleanFormatter
Implements ICustomFormatter, IFormatProvider

Private culture As CultureInfo

Public Sub New()
Me.New(CultureInfo.CurrentCulture)
End Sub

Public Sub New(culture As CultureInfo)
Me.culture = culture
End Sub

Public Function GetFormat(formatType As Type) As Object _
Implements IFormatProvider.GetFormat
If formatType Is GetType(ICustomFormatter) Then
Return Me
Else
Return Nothing
End If
End Function

Public Function Format(fmt As String, arg As Object,
formatProvider As IFormatProvider) As String _
Implements ICustomFormatter.Format
' Exit if another format provider is used.
If Not formatProvider.Equals(Me) Then Return Nothing

' Exit if the type to be formatted is not a Boolean
If Not TypeOf arg Is Boolean Then Return Nothing

Dim value As Boolean = CBool(arg)
Select culture.Name
Case "en-US"
Return value.ToString()
Case "fr-FR"
If value Then
Return "vrai"
Else
Return "faux"
End If
Case "ru-RU"
If value Then
Return "верно"
Else
Return "неверно"
End If
Case Else
Return value.ToString()
End Select
End Function
End Class
' The example displays the following output:
'          Value for '': True
'          Value for 'en-US': True
'          Value for 'fr-FR': vrai
'          Value for 'ru-RU': верно
``````

Opcionalmente, você pode usar arquivos de recurso para definir cadeias de caracteres boolianas específicas de cultura.Optionally, you can use resource files to define culture-specific Boolean strings.

### Convertendo de e para valores BoolianosConverting to and from Boolean values

A estrutura de Boolean implementa a interface IConvertible.The Boolean structure implements the IConvertible interface. Como resultado, você pode usar a classe Convert para executar conversões entre um valor de Boolean e qualquer outro tipo primitivo no .NET, ou você pode chamar as implementações explícitas da estrutura de Boolean.As a result, you can use the Convert class to perform conversions between a Boolean value and any other primitive type in .NET, or you can call the Boolean structure's explicit implementations. No entanto, conversões entre um Boolean e os tipos a seguir não têm suporte, portanto os métodos de conversão correspondentes geram uma exceção InvalidCastException:However, conversions between a Boolean and the following types are not supported, so the corresponding conversion methods throw an InvalidCastException exception:

Todas as conversões de números integral ou de ponto flutuante para valores Boolianos convertem valores diferentes de zero em valores `true` e zero para `false`.All conversions from integral or floating-point numbers to Boolean values convert non-zero values to `true` and zero values to `false`. O exemplo a seguir ilustra isso chamando sobrecargas selecionadas da classe Convert.ToBoolean.The following example illustrates this by calling selected overloads of the Convert.ToBoolean class.

``````using System;

public class Example
{
public static void Main()
{
Byte byteValue = 12;
Console.WriteLine(Convert.ToBoolean(byteValue));
Byte byteValue2 = 0;
Console.WriteLine(Convert.ToBoolean(byteValue2));
int intValue = -16345;
Console.WriteLine(Convert.ToBoolean(intValue));
long longValue = 945;
Console.WriteLine(Convert.ToBoolean(longValue));
SByte sbyteValue = -12;
Console.WriteLine(Convert.ToBoolean(sbyteValue));
double dblValue = 0;
Console.WriteLine(Convert.ToBoolean(dblValue));
float sngValue = .0001f;
Console.WriteLine(Convert.ToBoolean(sngValue));
}
}
// The example displays the following output:
//       True
//       False
//       True
//       True
//       True
//       False
//       True
``````
``````Module Example
Public Sub Main()
Dim byteValue As Byte = 12
Console.WriteLine(Convert.ToBoolean(byteValue))
Dim byteValue2 As Byte = 0
Console.WriteLine(Convert.ToBoolean(byteValue2))
Dim intValue As Integer = -16345
Console.WriteLine(Convert.ToBoolean(intValue))
Dim longValue As Long = 945
Console.WriteLine(Convert.ToBoolean(longValue))
Dim sbyteValue As SByte = -12
Console.WriteLine(Convert.ToBoolean(sbyteValue))
Dim dblValue As Double = 0
Console.WriteLine(Convert.ToBoolean(dblValue))
Dim sngValue As Single = .0001
Console.WriteLine(Convert.ToBoolean(sngValue))
End Sub
End Module
' The example displays the following output:
'       True
'       False
'       True
'       True
'       True
'       False
'       True
``````

Ao converter valores de ponto flutuante em valores Boolianos, os métodos de conversão executam uma comparação exata com zero.When converting from floating-point values to Boolean values, the conversion methods perform an exact comparison with zero. Se o valor de ponto flutuante tiver perdido a precisão, o resultado poderá ser inesperado.If the floating-point value has lost precision, the result can be unexpected. Isso é ilustrado no exemplo a seguir, no qual uma variável Double cujo valor deve ser zero é convertido em um valor booliano.This is illustrated in the following example, in which a Double variable whose value should be zero is converted to a Boolean value. Como mostra o exemplo, o resultado é `true` porque as adições repetidas de 0,2 resultaram em perda de precisão.As the example shows, the result is `true` because repeated additions of 0.2 have resulted in a loss of precision.

Ao converter de booliano em valores numéricos, os métodos de conversão da classe Convert convertem `true` em 1 e `false` como 0.When converting from Boolean to numeric values, the conversion methods of the Convert class convert `true` to 1 and `false` to 0. No entanto, Visual Basic funções de conversão convertem `true` em 255 (para conversões em valores Byte) ou-1 (para todas as outras conversões numéricas).However, Visual Basic conversion functions convert `true` to either 255 (for conversions to Byte values) or -1 (for all other numeric conversions). O exemplo a seguir converte `true` em valores numéricos usando um método Convert e, no caso do Visual Basic exemplo, usando o operador de conversão próprio da linguagem Visual Basic.The following example converts `true` to numeric values by using a Convert method, and, in the case of the Visual Basic example, by using the Visual Basic language's own conversion operator.

``````using System;

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

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

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

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

int intValue;
intValue = Convert.ToInt32(flag);
Console.WriteLine("{0} -> {1}", flag, intValue);
}
}
// The example displays the following output:
//       True -> 1
//       True -> 1
//       True -> 1
//       True -> 1
``````
``````Module Example
Public Sub Main()
Dim flag As Boolean = true

Dim byteValue As Byte
byteValue = Convert.ToByte(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, byteValue,
byteValue.GetType().Name)
byteValue = CByte(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, byteValue,
byteValue.GetType().Name)

Dim sbyteValue As SByte
sbyteValue = Convert.ToSByte(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue,
sbyteValue.GetType().Name)
sbyteValue = CSByte(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue,
sbyteValue.GetType().Name)

Dim dblValue As Double
dblValue = Convert.ToDouble(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, dblValue,
dblValue.GetType().Name)
dblValue = CDbl(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, dblValue,
dblValue.GetType().Name)

Dim intValue As Integer
intValue = Convert.ToInt32(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, intValue,
intValue.GetType().Name)
intValue = CInt(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, intValue,
intValue.GetType().Name)
End Sub
End Module
' The example displays the following output:
'       True -> 1 (Byte)
'       True -> 255 (Byte)
'       True -> 1 (SByte)
'       True -> -1 (SByte)
'       True -> 1 (Double)
'       True -> -1 (Double)
'       True -> 1 (Int32)
'       True -> -1 (Int32)
``````

Para conversões de Boolean para valores de cadeia de caracteres, consulte a seção Formatando valores Boolianos .For conversions from Boolean to string values, see the Formatting Boolean Values section. Para conversões de cadeias de caracteres para Boolean valores, consulte a seção analisando valores Boolianos .For conversions from strings to Boolean values, see the Parsing Boolean Values section.

### Analisando valores BoolianosParsing Boolean values

A estrutura de Boolean inclui dois métodos de análise estáticos, Parse e TryParse, que convertem uma cadeia de caracteres em um valor booliano.The Boolean structure includes two static parsing methods, Parse and TryParse, that convert a string to a Boolean value. A representação de cadeia de caracteres de um valor booliano é definida pelos equivalentes que não diferenciam maiúsculas de minúsculas dos valores dos campos TrueString e FalseString, que são "true" e "false", respectivamente.The string representation of a Boolean value is defined by the case-insensitive equivalents of the values of the TrueString and FalseString fields, which are "True" and "False", respectively. Em outras palavras, as únicas cadeias de caracteres que são analisadas com êxito são "true", "false", "true", "false" ou algum equivalente de maiúsculas e minúsculas.In other words, the only strings that parse successfully are "True", "False", "true", "false", or some mixed-case equivalent. Não é possível analisar com êxito cadeias de caracteres numéricas como "0" ou "1".You cannot successfully parse numeric strings such as "0" or "1". Caracteres de espaço em branco à esquerda ou à direita não são considerados ao executar a comparação de cadeia de caracteres.Leading or trailing white-space characters are not considered when performing the string comparison.

O exemplo a seguir usa os métodos Parse e TryParse para analisar várias cadeias de caracteres.The following example uses the Parse and TryParse methods to parse a number of strings. Observe que apenas os equivalentes que não diferenciam maiúsculas de minúsculas de "true" e "false" podem ser analisados com êxito.Note that only the case-insensitive equivalents of "True" and "False" can be successfully parsed.

``````using System;

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

Se você estiver programando em Visual Basic, poderá usar a função `CBool` para converter a representação de cadeia de caracteres de um número em um valor booliano.If you are programming in Visual Basic, you can use the `CBool` function to convert the string representation of a number to a Boolean value. "0" é convertido em `false`e a representação de cadeia de caracteres de qualquer valor diferente de zero é convertida em `true`."0" is converted to `false`, and the string representation of any non-zero value is converted to `true`. Se você não estiver programando em Visual Basic, deverá converter sua cadeia de caracteres numérica em um número antes de convertê-la em um booliano.If you are not programming in Visual Basic, you must convert your numeric string to a number before converting it to a Boolean. O exemplo a seguir ilustra isso convertendo uma matriz de inteiros em valores Boolianos.The following example illustrates this by converting an array of integers to Boolean values.

``````using System;

public class Example
{
public static void Main()
{
String[] values = { "09", "12.6", "0", "-13 " };
foreach (var value in values) {
bool success, result;
int number;
success = Int32.TryParse(value, out number);
if (success) {
// The method throws no exceptions.
result = Convert.ToBoolean(number);
Console.WriteLine("Converted '{0}' to {1}", value, result);
}
else {
Console.WriteLine("Unable to convert '{0}'", value);
}
}
}
}
// The example displays the following output:
//       Converted '09' to True
//       Unable to convert '12.6'
//       Converted '0' to False
//       Converted '-13 ' to True
``````
``````Module Example
Public Sub Main()
Dim values() As String = { "09", "12.6", "0", "-13 " }
For Each value In values
Dim success, result As Boolean
Dim number As Integer
success = Int32.TryParse(value, number)
If success Then
' The method throws no exceptions.
result = Convert.ToBoolean(number)
Console.WriteLine("Converted '{0}' to {1}", value, result)
Else
Console.WriteLine("Unable to convert '{0}'", value)
End If
Next
End Sub
End Module
' The example displays the following output:
'       Converted '09' to True
'       Unable to convert '12.6'
'       Converted '0' to False
'       Converted '-13 ' to True
``````

### Comparando valores BoolianosComparing Boolean values

Como os valores Boolianos são `true` ou `false`, há pouco motivo para chamar explicitamente o método CompareTo, que indica se uma instância é maior que, menor que ou igual a um valor especificado.Because Boolean values are either `true` or `false`, there is little reason to explicitly call the CompareTo method, which indicates whether an instance is greater than, less than, or equal to a specified value. Normalmente, para comparar duas variáveis Booleanas, você chama o método Equals ou usa o operador de igualdade de seu idioma.Typically, to compare two Boolean variables, you call the Equals method or use your language's equality operator.

No entanto, quando você deseja comparar uma variável booliana com o valor booliano literal `true` ou `false`, não é necessário fazer uma comparação explícita, pois o resultado da avaliação de um valor booliano é aquele valor booliano.However, when you want to compare a Boolean variable with the literal Boolean value `true` or `false`, it is not necessary to do an explicit comparison, because the result of evaluating a Boolean value is that Boolean value. Por exemplo, as expressõesFor example, the expressions

``````if (booleanValue) {
``````
``````If booleanValue Then
``````

eand

``````using System;

public class Example
{
public static void Main()
{
bool[] hasServiceCharges = { true, false };
Decimal subtotal = 120.62m;
Decimal shippingCharge = 2.50m;
Decimal serviceCharge = 5.00m;

foreach (var hasServiceCharge in hasServiceCharges) {
Decimal total = subtotal + shippingCharge +
(hasServiceCharge ? serviceCharge : 0);
Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.",
total, hasServiceCharge);
}
}
}
// The example displays output like the following:
//       hasServiceCharge = True: The total is \$128.12.
//       hasServiceCharge = False: The total is \$123.12.
``````
``````Module Example
Public Sub Main()
Dim hasServiceCharges() As Boolean = { True, False }
Dim subtotal As Decimal = 120.62d
Dim shippingCharge As Decimal = 2.50d
Dim serviceCharge As Decimal = 5.00d

For Each hasServiceCharge In hasServiceCharges
Dim total As Decimal = subtotal + shippingCharge +
If(hasServiceCharge, serviceCharge, 0)
Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.",
total, hasServiceCharge)
Next
End Sub
End Module
' The example displays output like the following:
'       hasServiceCharge = True: The total is \$128.12.
'       hasServiceCharge = False: The total is \$123.12.
``````

são equivalentes, mas o segundo é mais compacto.are equivalent, but the second is more compact. No entanto, ambas as técnicas oferecem desempenho comparável.However, both techniques offer comparable performance.

### Trabalhando com Boolianos como valores bináriosWorking with Booleans as binary values

Um valor booliano ocupa um byte de memória, como mostra C# o exemplo a seguir.A Boolean value occupies one byte of memory, as the following C# example shows. O exemplo deve ser compilado com a opção `/unsafe`.The example must be compiled with the `/unsafe` switch.

``````using System;

public struct BoolStruct
{
public bool flag1;
public bool flag2;
public bool flag3;
public bool flag4;
public bool flag5;
}

public class Example
{
public static void Main()
{
unsafe {
BoolStruct b = new BoolStruct();
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
``````

O bit de ordem inferior do byte é usado para representar seu valor.The byte's low-order bit is used to represent its value. Um valor de 1 representa `true`; um valor de 0 representa `false`.A value of 1 represents `true`; a value of 0 represents `false`.

Warning

Você pode usar a estrutura de System.Collections.Specialized.BitVector32 para trabalhar com conjuntos de valores Boolianos.You can use the System.Collections.Specialized.BitVector32 structure to work with sets of Boolean values.

Você pode converter um valor booliano em sua representação binária chamando o método BitConverter.GetBytes(Boolean).You can convert a Boolean value to its binary representation by calling the BitConverter.GetBytes(Boolean) method. O método retorna uma matriz de bytes com um único elemento.The method returns a byte array with a single element. Para restaurar um valor booliano de sua representação binária, você pode chamar o método BitConverter.ToBoolean(Byte[], Int32).To restore a Boolean value from its binary representation, you can call the BitConverter.ToBoolean(Byte[], Int32) method.

O exemplo a seguir chama o método BitConverter.GetBytes para converter um valor booliano em sua representação binária e exibe os bits individuais do valor e, em seguida, chama o método BitConverter.ToBoolean para restaurar o valor de sua representação binária.The following example calls the BitConverter.GetBytes method to convert a Boolean value to its binary representation and displays the individual bits of the value, and then calls the BitConverter.ToBoolean method to restore the value from its binary representation.

``````using System;

public class Example
{
public static void Main()
{
bool[] flags = { true, false };
foreach (var flag in flags) {
// Get binary representation of flag.
Byte value = BitConverter.GetBytes(flag)[0];
Console.WriteLine("Original value: {0}", flag);
Console.WriteLine("Binary value:   {0} ({1})", value,
GetBinaryString(value));
// Restore the flag from its binary representation.
bool newFlag = BitConverter.ToBoolean( new Byte[] { value }, 0);
Console.WriteLine("Restored value: {0}\n", flag);
}
}

private static string GetBinaryString(Byte value)
{
String retVal = Convert.ToString(value, 2);
return new String('0', 8 - retVal.Length) + retVal;
}
}
// The example displays the following output:
//       Original value: True
//       Binary value:   1 (00000001)
//       Restored value: True
//
//       Original value: False
//       Binary value:   0 (00000000)
//       Restored value: False
``````
``````Module Example
Public Sub Main()
Dim flags() As Boolean = { True, False }
For Each flag In flags
' Get binary representation of flag.
Dim value As Byte = BitConverter.GetBytes(flag)(0)
Console.WriteLine("Original value: {0}", flag)
Console.WriteLine("Binary value:   {0} ({1})", value,
GetBinaryString(value))
' Restore the flag from its binary representation.
Dim newFlag As Boolean = BitConverter.ToBoolean( { value }, 0)
Console.WriteLine("Restored value: {0}", flag)
Console.WriteLine()
Next
End Sub

Private Function GetBinaryString(value As Byte) As String
Dim retVal As String = Convert.ToString(value, 2)
Return New String("0"c, 8 - retVal.Length) + retVal
End Function
End Module
' The example displays the following output:
'       Original value: True
'       Binary value:   1 (00000001)
'       Restored value: True
'
'       Original value: False
'       Binary value:   0 (00000000)
'       Restored value: False
``````

### Executando operações com valores BoolianosPerforming operations with Boolean values

Esta seção ilustra como os valores Boolianos são usados em aplicativos.This section illustrates how Boolean values are used in apps. A primeira seção discute seu uso como um sinalizador.The first section discusses its use as a flag. O segundo ilustra seu uso para operações aritméticas.The second illustrates its use for arithmetic operations.

#### Valores Boolianos como sinalizadoresBoolean values as flags

Variáveis Booleanas são usadas com mais frequência como sinalizadores, para sinalizar a presença ou a ausência de alguma condição.Boolean variables are most commonly used as flags, to signal the presence or absence of some condition. Por exemplo, no método 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 de minúsculas (`ignoreCase` é `true`) ou diferencia maiúsculas de minúsculas (`ignoreCase` é `false`).For example, in the String.Compare(String, String, Boolean) method, the final parameter, `ignoreCase`, is a flag that indicates whether the comparison of two strings is case-insensitive (`ignoreCase` is `true`) or case-sensitive (`ignoreCase` is `false`). O valor do sinalizador pode então ser avaliado em uma instrução condicional.The value of the flag can then be evaluated in a conditional statement.

O exemplo a seguir usa um aplicativo de console simples para ilustrar o uso de variáveis boolianas como sinalizadores.The following example uses a simple console app to illustrate the use of Boolean variables as flags. O aplicativo aceita parâmetros de linha de comando que permitem que a saída seja redirecionada para um arquivo especificado (a opção `/f`) e que permite que a saída seja enviada tanto para um arquivo especificado quanto para o console (a opção `/b`).The app accepts command-line parameters that enable output to be redirected to a specified file (the `/f` switch), and that enable output to be sent both to a specified file and to the console (the `/b` switch). O aplicativo define um sinalizador chamado `isRedirected` para indicar se a saída deve ser enviada a um arquivo e um sinalizador chamado `isBoth` para indicar que a saída deverá ser enviada ao console.The app defines a flag named `isRedirected` to indicate whether output is to be sent to a file, and a flag named `isBoth` to indicate that output should be sent to the console.

``````using System;
using System.IO;

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);
msg = String.Format("Application ended normally at {0}", DateTime.Now);
Console.WriteLine(msg);
if (isBoth) sw.WriteLine(msg);
if (isRedirected) sw.Close();
}

private static void ShowSyntax(String errMsg)
{
Console.WriteLine(errMsg);
Console.WriteLine("\nSyntax: Example [[/f <filename> [/b]]\n");
}
}
``````
``````Imports System.IO

Module Example
Public Sub Main()
' Initialize flag variables.
Dim isRedirected, isBoth As Boolean
Dim fileName As String = ""
Dim sw As StreamWriter = Nothing

' Get any command line arguments.
Dim args() As String = Environment.GetCommandLineArgs()
' Handle any arguments.
If args.Length > 1 Then
For ctr = 1 To args.Length - 1
Dim arg As String = args(ctr)
If arg.StartsWith("/") OrElse arg.StartsWith("-") Then
Select Case arg.Substring(1).ToLower()
Case "f"
isRedirected = True
If args.Length < ctr + 2 Then
ShowSyntax("The /f switch must be followed by a filename.")
Exit Sub
End If
fileName = args(ctr + 1)
ctr += 1
Case "b"
isBoth = True
Case Else
ShowSyntax(String.Format("The {0} switch is not supported",
args(ctr)))
Exit Sub
End Select
End If
Next
End If

' If isBoth is True, isRedirected must be True.
If isBoth And Not isRedirected Then
ShowSyntax("The /f switch must be used if /b is used.")
Exit Sub
End If

' Handle output.
If isRedirected Then
sw = New StreamWriter(fileName)
If Not IsBoth Then
Console.SetOut(sw)
End If
End If
Dim msg As String = String.Format("Application began at {0}", Date.Now)
Console.WriteLine(msg)
If isBoth Then sw.WriteLine(msg)
msg = String.Format("Application ended normally at {0}", Date.Now)
Console.WriteLine(msg)
If isBoth Then sw.WriteLine(msg)
If isRedirected Then sw.Close()
End Sub

Private Sub ShowSyntax(errMsg As String)
Console.WriteLine(errMsg)
Console.WriteLine()
Console.WriteLine("Syntax: Example [[/f <filename> [/b]]")
Console.WriteLine()
End Sub
End Module
``````

#### Operações booleanas e aritméticasBooleans and arithmetic operations

Algumas vezes, um valor booliano é usado para indicar a presença de uma condição que dispara um cálculo matemático.A Boolean value is sometimes used to indicate the presence of a condition that triggers a mathematical calculation. Por exemplo, uma variável `hasShippingCharge` pode servir como um sinalizador para indicar se os encargos de remessa devem ser adicionados a um valor de nota fiscal.For example, a `hasShippingCharge` variable might serve as a flag to indicate whether to add shipping charges to an invoice amount.

Como uma operação com um valor `false` não tem efeito sobre o resultado de uma operação, não é necessário converter o booliano em um valor integral para usar na operação matemática.Because an operation with a `false` value has no effect on the result of an operation, it is not necessary to convert the Boolean to an integral value to use in the mathematical operation. Em vez disso, você pode usar a lógica condicional.Instead, you can use conditional logic.

O exemplo a seguir computa um valor que consiste em um subtotal, um encargo de remessa e um encargo de serviço opcional.The following example computes an amount that consists of a subtotal, a shipping charge, and an optional service charge. A variável `hasServiceCharge` determina se o encargo de serviço é aplicado.The `hasServiceCharge` variable determines whether the service charge is applied. Em vez de converter `hasServiceCharge` em um valor numérico e multiplica-lo pela quantidade de encargo de serviço, o exemplo usa a lógica condicional para adicionar o valor de encargo de serviço, se aplicável.Instead of converting `hasServiceCharge` to a numeric value and multiplying it by the amount of the service charge, the example uses conditional logic to add the service charge amount if it is applicable.

``````using System;

public class Example
{
public static void Main()
{
bool[] hasServiceCharges = { true, false };
Decimal subtotal = 120.62m;
Decimal shippingCharge = 2.50m;
Decimal serviceCharge = 5.00m;

foreach (var hasServiceCharge in hasServiceCharges) {
Decimal total = subtotal + shippingCharge +
(hasServiceCharge ? serviceCharge : 0);
Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.",
total, hasServiceCharge);
}
}
}
// The example displays output like the following:
//       hasServiceCharge = True: The total is \$128.12.
//       hasServiceCharge = False: The total is \$123.12.
``````
``````Module Example
Public Sub Main()
Dim hasServiceCharges() As Boolean = { True, False }
Dim subtotal As Decimal = 120.62d
Dim shippingCharge As Decimal = 2.50d
Dim serviceCharge As Decimal = 5.00d

For Each hasServiceCharge In hasServiceCharges
Dim total As Decimal = subtotal + shippingCharge +
If(hasServiceCharge, serviceCharge, 0)
Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.",
total, hasServiceCharge)
Next
End Sub
End Module
' The example displays output like the following:
'       hasServiceCharge = True: The total is \$128.12.
'       hasServiceCharge = False: The total is \$123.12.
``````

#### Boolianos e interoperabilidadeBooleans and interop

Embora o empacotamento de tipos de dados base em COM seja geralmente simples, o tipo de dados Boolean é uma exceção.While marshaling base data types to COM is generally straightforward, the Boolean data type is an exception. Você pode aplicar o atributo MarshalAsAttribute para empacotar o tipo de Boolean para qualquer uma das seguintes representações:You can apply the MarshalAsAttribute attribute to marshal the Boolean type to any of the following representations:

Tipo de enumeraçãoEnumeration type Formato não gerenciadoUnmanaged format
UnmanagedType.Bool Um valor inteiro de 4 bytes, em que qualquer valor diferente de zero representa `true` e 0 representa `false`.A 4-byte integer value, where any nonzero value represents `true` and 0 represents `false`. Esse é o formato padrão de um campo de Boolean em uma estrutura e de um parâmetro Boolean em chamadas de invocação de plataforma.This is the default format of a Boolean field in a structure and of a Boolean parameter in platform invoke calls.
UnmanagedType.U1 Um valor inteiro de 1 byte, em que o 1 representa `true` e 0 representa `false`.A 1-byte integer value, where the 1 represents `true` and 0 represents `false`.
UnmanagedType.VariantBool Um valor inteiro de 2 bytes, em que-1 representa `true` e 0 representa `false`.A 2-byte integer value, where -1 represents `true` and 0 represents `false`. Esse é o formato padrão de um parâmetro de Boolean em chamadas de interoperabilidade COM.This is the default format of a Boolean parameter in COM interop calls.

## Fields

 Representa o valor booliano `false` como uma cadeia de caracteres.Represents the Boolean value `false` as a string. Esse campo é somente leitura.This field is read-only. Representa o valor booliano `true` como uma cadeia de caracteres.Represents the Boolean value `true` as a string. Esse campo é somente leitura.This field is read-only.