Boolean Struct

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Rappresenta un valore booleano (true o false).

public value class bool : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>

public value class bool : IComparable, IConvertible

public value class bool : 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)

Ereditarietà: Object

ValueType
Boolean

Attributi: SerializableAttribute ComVisibleAttribute

Implementazioni: IComparable IComparable<Boolean> IConvertible IEquatable<Boolean>

Commenti

BooleanUn'istanza può avere uno dei due valori seguenti: o true false .

La Boolean struttura fornisce metodi che supportano le attività seguenti:

Conversione di valori booleani in stringhe: ToString
Analisi delle stringhe per convertirle in valori booleani: Parse e TryParse
Confronto tra valori: CompareTo e Equals

Le sezioni seguenti illustrano queste attività e altri dettagli sull'utilizzo:

Formattare i valori booleani
Eseguire la conversione da e verso valori booleani
Analizzare valori booleani
Confrontare valori booleani
Usare i valori booleani come valori binari
Eseguire operazioni con valori booleani
Valori booleani e interoperabilità

Formattare i valori booleani

La rappresentazione di stringa di Boolean un oggetto è "True" per un true valore o "False" per un false valore. La rappresentazione di stringa Boolean di un valore è definita dai campi e di sola TrueString FalseString lettura.

Usare il metodo ToString per convertire valori booleani in stringhe. La struttura booleana include due overload: il metodo senza parametri e il metodo , che include ToString un parametro che controlla la ToString() ToString(IFormatProvider) formattazione. Tuttavia, poiché questo parametro viene ignorato, i due overload producono stringhe identiche. Il ToString(IFormatProvider) metodo non supporta la formattazione sensibile alle impostazioni cultura.

Nell'esempio seguente viene illustrata la formattazione con il ToString metodo . Si noti che nell'esempio viene utilizzata la funzionalità di formattazione composita, quindi il ToString metodo viene chiamato in modo implicito.

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

Poiché la Boolean struttura può avere solo due valori, è facile aggiungere una formattazione personalizzata. Per una formattazione personalizzata semplice in cui altri valori letterali stringa vengono sostituiti con "True" e "False", è possibile usare qualsiasi funzionalità di valutazione condizionale supportata dal linguaggio, ad esempio l'operatore condizionale in C# o l'operatore If in Visual Basic. L'esempio seguente usa questa tecnica per formattare i valori Boolean come "Yes" e "No" anziché "True" e "False".

using System;

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

      Console.WriteLine("It is raining: {0}",
                        raining ? "Yes" : "No");
      Console.WriteLine("The bus is late: {0}",
                        busLate ? "Yes" : "No" );
   }
}
// The example displays the following output:
//       It is raining: No
//       The bus is late: Yes

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

Per operazioni di formattazione personalizzate più complesse, inclusa la formattazione sensibile alle impostazioni cultura, è possibile chiamare il String.Format(IFormatProvider, String, Object[]) metodo e fornire ICustomFormatter un'implementazione . Nell'esempio seguente vengono implementate le interfacce e per fornire stringhe booleane con distinzione delle impostazioni cultura per le impostazioni cultura inglese (Stati Uniti), francese (Francia) e russo ICustomFormatter IFormatProvider (Russia).

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': верно

Facoltativamente, è possibile usare i file di risorse per definire stringhe booleane specifiche delle impostazioni cultura.

Eseguire la conversione da e verso valori booleani

La Boolean struttura implementa IConvertible l'interfaccia . Di conseguenza, è possibile usare la classe per eseguire conversioni tra un valore e qualsiasi altro tipo primitivo in .NET oppure è possibile chiamare le implementazioni Convert Boolean esplicite Boolean della struttura. Tuttavia, le conversioni tra e i tipi seguenti non sono supportate, pertanto i Boolean metodi di conversione corrispondenti generano un'eccezione: InvalidCastException

Conversione Boolean tra Char e Convert.ToBoolean(Char) (metodi e Convert.ToChar(Boolean) )
Conversione Boolean tra DateTime e Convert.ToBoolean(DateTime) (metodi e Convert.ToDateTime(Boolean) )

Tutte le conversioni da numeri integrali o a virgola mobile a valori booleani convertono valori diversi da zero in true e valori zero in false . L'esempio seguente illustra questo problema chiamando gli overload selezionati della Convert.ToBoolean classe .

using System;

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

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

Quando si esegue la conversione da valori booleani a valori numerici, i metodi di conversione della classe Convert vengono convertiti true in 1 e in false 0. Tuttavia, Visual Basic funzioni di conversione vengono convertite in true 255 (per le conversioni in valori) o -1 (per tutte le Byte altre conversioni numeriche). Nell'esempio seguente viene eseguita la conversione in valori numerici usando un metodo e, nel caso true dell'esempio Visual Basic, usando l'operatore di conversione del linguaggio Convert Visual Basic.

using System;

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

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

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

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

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

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)

Per le conversioni Boolean da a valori stringa, vedere la sezione Formattazione di valori booleani. Per le conversioni da stringhe a Boolean valori, vedere la sezione Analisi dei valori booleani.

Analizzare valori booleani

La Boolean struttura include due metodi di analisi statici, e , che Parse TryParse convertono una stringa in un valore booleano. La rappresentazione di stringa di un valore booleano è definita dagli equivalenti senza distinzione tra maiuscole e minuscole dei valori dei campi TrueString FalseString e, rispettivamente, "True" e "False". In altre parole, le uniche stringhe che vengono analizzate correttamente sono "True", "False", "true", "false" o alcuni equivalenti di maiuscole e minuscole. Non è possibile analizzare correttamente stringhe numeriche, ad esempio "0" o "1". Gli spazi vuoti iniziali o finali non vengono considerati quando si esegue il confronto tra stringhe.

Nell'esempio seguente vengono Parse utilizzati i metodi e per analizzare un numero di TryParse stringhe. Si noti che solo gli equivalenti senza distinzione tra maiuscole e minuscole di "True" e "False" possono essere analizzati correttamente.

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 si esegue la programmazione in Visual Basic, è possibile usare la funzione per convertire la rappresentazione di stringa di un CBool numero in un valore booleano. "0" viene convertito in e la rappresentazione di stringa di qualsiasi valore false diverso da zero viene convertita in true . Se non si esegue la programmazione in Visual Basic, è necessario convertire la stringa numerica in un numero prima di convertirla in un valore booleano. L'esempio seguente illustra questa operazione convertendo una matrice di numeri interi in valori booleani.

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

Confrontare valori booleani

Poiché i valori booleani sono o , non vi è alcun motivo per chiamare in modo esplicito il metodo , che indica se un'istanza è maggiore, minore o true uguale a un valore false CompareTo specificato. In genere, per confrontare due variabili booleane, chiamare il Equals metodo o usare l'operatore di uguaglianza del linguaggio.

Tuttavia, quando si vuole confrontare una variabile booleana con il valore booleano letterale o , non è necessario eseguire un confronto esplicito, perché il risultato della valutazione di un valore booleano è tale valore true false booleano. Ad esempio, le espressioni

if (booleanValue == true) {

If booleanValue = True Then

if (booleanValue) {

If booleanValue Then

sono equivalenti, ma il secondo è più compatto. Tuttavia, entrambe le tecniche offrono prestazioni simili.

Usare i valori booleani come valori binari

Un valore booleano occupa un byte di memoria, come illustrato nell'esempio C# seguente. L'esempio deve essere compilato con /unsafe l'opzione .

using System;

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

public class Example
{
   public static void Main()
   {
      unsafe {
         BoolStruct b = new BoolStruct();
         bool* addr = (bool*) &b;
         Console.WriteLine("Size of BoolStruct: {0}", sizeof(BoolStruct));
         Console.WriteLine("Field offsets:");
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag1 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag2 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag3 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag4 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag5 - addr);
      }
   }
}
// The example displays the following output:
//       Size of BoolStruct: 5
//       Field offsets:
//          flag1: 0
//          flag1: 1
//          flag1: 2
//          flag1: 3
//          flag1: 4

Il bit di ordine basso del byte viene usato per rappresentarne il valore. Il valore 1 rappresenta . Il true valore 0 rappresenta false .

Suggerimento

È possibile usare la System.Collections.Specialized.BitVector32 struttura per usare set di valori booleani.

È possibile convertire un valore booleano nella relativa rappresentazione binaria chiamando il BitConverter.GetBytes(Boolean) metodo . Il metodo restituisce una matrice di byte con un singolo elemento. Per ripristinare un valore booleano dalla relativa rappresentazione binaria, è possibile chiamare il BitConverter.ToBoolean(Byte[], Int32) metodo .

Nell'esempio seguente viene chiamato il metodo per convertire un valore booleano nella relativa rappresentazione binaria e vengono visualizzati i singoli bit del valore e quindi viene chiamato il metodo per ripristinare il valore dalla relativa BitConverter.GetBytes BitConverter.ToBoolean rappresentazione binaria.

using System;

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

   private static string GetBinaryString(Byte value)
   {
      string retVal = Convert.ToString(value, 2);
      return new string('0', 8 - retVal.Length) + retVal;
   }
}
// The example displays the following output:
//       Original value: True
//       Binary value:   1 (00000001)
//       Restored value: True
//
//       Original value: False
//       Binary value:   0 (00000000)
//       Restored value: False

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

Eseguire operazioni con valori booleani

Questa sezione illustra come vengono usati i valori booleani nelle app. La prima sezione ne illustra l'uso come flag. Il secondo illustra l'uso per le operazioni aritmetiche.

Valori booleani come flag

Le variabili booleane vengono in genere usate come flag per segnalare la presenza o l'assenza di una condizione. Nel metodo , ad esempio, il parametro finale, , è un flag che indica se il confronto tra due stringhe non fa distinzione tra maiuscole e minuscole ( è ) o fa distinzione tra maiuscole e minuscole String.Compare(String, String, Boolean) ignoreCase ( è ignoreCase true ignoreCase false ). Il valore del flag può quindi essere valutato in un'istruzione condizionale.

L'esempio seguente usa una semplice app console per illustrare l'uso di variabili booleane come flag. L'app accetta parametri della riga di comando che consentono il reindirizzamento dell'output a un file specificato (opzione ) e che consentono l'invio dell'output sia a un file specificato che alla /f console (opzione /b ). L'app definisce un flag denominato per indicare se l'output deve essere inviato a un file e un flag denominato per indicare che isRedirected l'output deve essere inviato alla isBoth 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");
   }
}

Imports System.IO
Imports System.Threading

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)
      Thread.Sleep(5000)
      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

Valori booleani e operazioni aritmetiche

Un valore booleano viene talvolta usato per indicare la presenza di una condizione che attiva un calcolo matematico. Ad esempio, una variabile può fungere da flag per indicare se aggiungere addebiti hasShippingCharge per la spedizione a un importo della fattura.

Poiché un'operazione con un valore non ha alcun effetto sul risultato di un'operazione, non è necessario convertire il valore booleano in un valore integrale da usare false nell'operazione matematica. È invece possibile usare la logica condizionale.

Nell'esempio seguente viene calcolato un importo costituito da un subtotale, un addebito per la spedizione e un addebito di servizio facoltativo. La hasServiceCharge variabile determina se viene applicato l'addebito del servizio. Anziché eseguire la conversione in un valore numerico e moltiplicarlo per l'importo dell'addebito del servizio, nell'esempio viene utilizzata la logica condizionale per aggiungere l'importo dell'addebito del servizio, se hasServiceCharge applicabile.

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.

Valori booleani e interoperabilità

Anche se il marshalling dei tipi di dati di base in COM è in genere semplice, il Boolean tipo di dati è un'eccezione. È possibile applicare MarshalAsAttribute l'attributo per effettuare il Boolean marshalling del tipo a una delle rappresentazioni seguenti:

Tipo di enumerazione	Formato non gestito
UnmanagedType.Bool	Valore intero a 4 byte, dove qualsiasi valore diverso da zero rappresenta `true` e 0 rappresenta `false` . Si tratta del formato predefinito di un campo in una struttura e di un parametro nelle platform invoke Boolean Boolean chiamate.
UnmanagedType.U1	Valore intero a 1 byte, dove 1 `true` rappresenta e 0 rappresenta `false` .
UnmanagedType.VariantBool	Valore intero a 2 byte, dove -1 `true` rappresenta e 0 rappresenta `false` . Si tratta del formato predefinito di un parametro Boolean nelle chiamate di interoperabilità COM.

Campi

FalseString	Rappresenta un valore booleano `false` sotto forma di stringa. Questo campo è di sola lettura.
TrueString	Rappresenta un valore booleano `true` sotto forma di stringa. Questo campo è di sola lettura.

Metodi

CompareTo(Boolean)	Confronta questa istanza con un oggetto Boolean specificato e restituisce un intero che indica la relazione reciproca.
CompareTo(Object)	Confronta l'istanza con un oggetto specificato e restituisce un valore intero che indica la relazione reciproca.
Equals(Boolean)	Restituisce un valore che indica se questa istanza è uguale a un oggetto Boolean specificato.
Equals(Object)	Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.
GetHashCode()	Restituisce il codice hash per l'istanza.
GetTypeCode()	Restituisce il codice del tipo per il tipo di valore Boolean.
Parse(ReadOnlySpan<Char>)	Converte la rappresentazione in forma di intervallo specificata di un valore logico nell'oggetto Boolean equivalente.
Parse(String)	Converte la rappresentazione di stringa specificata di un valore logico nel relativo valore Boolean equivalente.
ToString()	Converte il valore dell'istanza corrente nella rappresentazione di stringa equivalente ("True" o "False").
ToString(IFormatProvider)	Converte il valore dell'istanza corrente nella rappresentazione di stringa equivalente ("True" o "False").
TryFormat(Span<Char>, Int32)	Tenta di formattare il valore dell'istanza booleana corrente nell'intervallo di caratteri specificato.
TryParse(ReadOnlySpan<Char>, Boolean)	Tenta di convertire la rappresentazione in forma di intervallo specificata di un valore logico nell'oggetto Boolean equivalente.
TryParse(String, Boolean)	Prova a convertire la rappresentazione di stringa specificata di un valore logico nell'oggetto Boolean equivalente.

Implementazioni dell'interfaccia esplicita

IComparable.CompareTo(Object)	Confronta l'istanza corrente con un altro oggetto dello stesso tipo e restituisce un intero che indica se l'istanza corrente precede, segue o si trova nella stessa posizione dell'altro oggetto all'interno dell'ordinamento.
IConvertible.GetTypeCode()	Restituisce l'oggetto TypeCode per questa istanza.
IConvertible.ToBoolean(IFormatProvider)	Per una descrizione di questo membro, vedere ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Per una descrizione di questo membro, vedere ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.
IConvertible.ToDateTime(IFormatProvider)	Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Per una descrizione di questo membro, vedere ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Per una descrizione di questo membro, vedere ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Per una descrizione di questo membro, vedere ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Per una descrizione di questo membro, vedere ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Per una descrizione di questo membro, vedere ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Per una descrizione di questo membro, vedere ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Per una descrizione di questo membro, vedere ToSingle(IFormatProvider).
IConvertible.ToString(IFormatProvider)	Converte il valore di questa istanza in una stringa equivalente usando le informazioni di formattazione specifiche delle impostazioni cultura.
IConvertible.ToType(Type, IFormatProvider)	Per una descrizione di questo membro, vedere ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Per una descrizione di questo membro, vedere ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Per una descrizione di questo membro, vedere ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Per una descrizione di questo membro, vedere ToUInt64(IFormatProvider).

Si applica a

Thread safety

Tutti i membri di questo tipo sono thread-safe. I membri che sembrano modificare lo stato dell'istanza restituiscono effettivamente una nuova istanza inizializzata con il nuovo valore. Come per qualsiasi altro tipo, la lettura e la scrittura in una variabile condivisa che contiene un'istanza di questo tipo devono essere protette da un blocco per garantire la thread safety.