# Boolean Estrutura

## Definição

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.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>``````
``public struct Boolean : IComparable, IComparable<bool>, IEquatable<bool>``
``````type bool = struct
interface IConvertible``````
``````[<System.Serializable>]
type bool = struct
interface IConvertible``````
``````[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
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)``````
Herança
Boolean
Atributos
Implementações

## Comentários

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

A Boolean estrutura 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:

### Formatar valores BoolianosFormat Boolean values

A representação de cadeia de caracteres de a Boolean é "true" para um `true` valor ou "false" para um `false` valor.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 Boolean valor é definida pelos campos somente leitura TrueString e FalseString .The string representation of a Boolean value is defined by the read-only TrueString and FalseString fields.

Você usa o ToString método para converter valores Boolianos em cadeias de caracteres.You use the ToString method to convert Boolean values to strings. A estrutura booliana inclui duas ToString sobrecargas: o método sem parâmetros ToString() e o ToString(IFormatProvider) método, 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 ToString(IFormatProvider) método 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 ToString método.The following example illustrates formatting with the ToString method. Observe que o exemplo usa o recurso de formatação composta , portanto, o ToString método é 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 Boolean estrutura 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 com suporte em seu idioma, como o operador condicional em C# 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 Boolean valores 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 String.Format(IFormatProvider, String, Object[]) método e fornecer uma ICustomFormatter implementação.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 ICustomFormatter as IFormatProvider interfaces e para fornecer cadeias de caracteres booleanas sensíveis à cultura para as culturas em 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.

### Converter de e para valores BoolianosConvert to and from Boolean values

A Boolean estrutura implementa a IConvertible interface.The Boolean structure implements the IConvertible interface. Como resultado, você pode usar a Convert classe para executar conversões entre um Boolean valor e qualquer outro tipo primitivo no .net ou pode chamar as Boolean implementações explícitas da estrutura.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, não há suporte para conversões entre um Boolean e os seguintes tipos, portanto os métodos de conversão correspondentes geram uma InvalidCastException exceção: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 para `true` e valores 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 Convert.ToBoolean classe.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 de booliano em valores numéricos, os métodos de conversão da Convert classe são convertidos `true` em 1 e `false` em 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 são convertidas `true` em 255 (para conversões em Byte valores) 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 Convert método e, no caso do Visual Basic exemplo, usando o próprio operador de conversão do idioma 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.

### Analisar valores BoolianosParse Boolean values

A Boolean estrutura 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 TrueString FalseString campos e, 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 Parse os TryParse métodos e 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 `CBool` função 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
``````

### Comparar valores BoolianosCompare Boolean values

Como os valores Boolianos são `true` ou `false` , há pouco motivo para chamar explicitamente o CompareTo método, que indica se uma instância é maior que, menor 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 Equals método 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, porque o resultado da avaliação de um valor booliano é o 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 == true) {
``````
``````If booleanValue = True Then
``````

eand

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

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.

### Trabalhar com Boolianos como valores bináriosWork with Booleans as binary values

Um valor booliano ocupa um byte de memória, como mostra o exemplo de C# a seguir.A Boolean value occupies one byte of memory, as the following C# example shows. O exemplo deve ser compilado com a `/unsafe` opção.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`.

Dica

Você pode usar a System.Collections.Specialized.BitVector32 estrutura 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 BitConverter.GetBytes(Boolean) método.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 BitConverter.ToBoolean(Byte[], Int32) método.To restore a Boolean value from its binary representation, you can call the BitConverter.ToBoolean(Byte[], Int32) method.

O 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.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
``````

### Executar operações com valores BoolianosPerform 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 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 não diferencia maiúsculas de minúsculas ( `ignoreCase` is `true` ) ou diferencia maiúsculas de minúsculas ( `ignoreCase` is) `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 `/f` opção) e que permite que a saída seja enviada para um arquivo especificado e para o console (a `/b` opção).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 `hasShippingCharge` variável 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 `false` valor não tem nenhum 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 `hasServiceCharge` variável determina se o encargo de serviço é aplicado.The `hasServiceCharge` variable determines whether the service charge is applied. Em vez de converter `hasServiceCharge` para um valor numérico e multiplicar isso 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 Boolean tipo de dados é uma exceção.While marshaling base data types to COM is generally straightforward, the Boolean data type is an exception. Você pode aplicar o MarshalAsAttribute atributo para empacotar o Boolean tipo 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 `true` de zero representa 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 Boolean campo em uma estrutura e de um Boolean parâmetro 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 Boolean parâmetro em chamadas de interoperabilidade com.This is the default format of a Boolean parameter in COM interop calls.

## Campos

 Representa o valor booliano `false` como uma cadeia de caracteres.Represents the Boolean value `false` as a string. Este 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. Este campo é somente leitura.This field is read-only.