Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Struttura Boolean

 

Data di pubblicazione: ottobre 2016

Rappresenta un valore booleano (true o false).

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

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

NomeDescrizione
System_CAPS_pubmethodCompareTo(Boolean)

Confronta questa istanza con un oggetto Boolean specificato e restituisce un intero che indica la relazione reciproca.

System_CAPS_pubmethodCompareTo(Object)

Confronta questa istanza con un oggetto specificato e restituisce un valore intero che indica la relazione reciproca.

System_CAPS_pubmethodEquals(Boolean)

Restituisce un valore che indica se questa istanza è uguale a un oggetto Boolean specificato.

System_CAPS_pubmethodEquals(Object)

Restituisce un valore che indica se questa istanza è uguale ad un oggetto specificato. (Esegue l'override di ValueType.Equals(Object).)

System_CAPS_pubmethodGetHashCode()

Restituisce il codice hash per questa istanza. (Esegue l'override di ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Ottiene l'oggetto Type dell'istanza corrente.(Ereditato da Object.)

System_CAPS_pubmethodGetTypeCode()

Restituisce il codice del tipo per il tipo di valore Boolean.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Converte la rappresentazione di stringa specificata di un valore logico nel relativo valore Boolean equivalente.

System_CAPS_pubmethodToString()

Converte il valore di questa istanza nella sua equivalente rappresentazione in forma di stringa ("True" o "False"). (Esegue l'override di ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Converte il valore di questa istanza nella sua equivalente rappresentazione in forma di stringa ("True" o "False").

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Boolean)

Prova a convertire la rappresentazione di stringa specificata di un valore logico nell'oggetto Boolean equivalente. Un valore restituito indica se la conversione è riuscita o meno.

NomeDescrizione
System_CAPS_pubfieldSystem_CAPS_staticFalseString

Rappresenta un valore booleano false sotto forma di stringa. Questo campo è di sola lettura.

System_CAPS_pubfieldSystem_CAPS_staticTrueString

Rappresenta un valore booleano true sotto forma di stringa. Questo campo è di sola lettura.

NomeDescrizione
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToUInt64.

Oggetto Boolean istanza può avere uno dei due valori: true, o false.

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

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

Formattazione di valori booleani
Conversione da e verso i valori booleani
L'analisi dei valori booleani
Confronto tra valori booleani
Utilizzo di valori booleani come valori binari
Esecuzione di operazioni con valori booleani
I valori booleani e interoperabilità

Rappresentazione di stringa di un Boolean è "True" per un true valore o "False" per un false valore. Rappresentazione di stringa di un Boolean valore è definito da sola lettura TrueString e FalseString campi.

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

L'esempio seguente illustra la formattazione con la ToString metodo. Si noti che nell'esempio viene utilizzato il formattazione composita funzionalità, pertanto la 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

Poiché il Boolean struttura può avere solo due valori, è facile aggiungere formattazione personalizzata. Per una semplice formattazione personalizzata in cui un'altra stringa vengono sostituiti con valori letterali per "True" e "False", è possibile utilizzare qualsiasi funzionalità di valutazione condizionale supportato dal linguaggio di, ad esempio il operatore condizionale in c# o se operatore in Visual Basic. Nell'esempio seguente viene utilizzata questa tecnica per formattare Boolean valori 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

Per più complesse operazioni di formattazione personalizzate, inclusa la formattazione delle impostazioni cultura, è possibile chiamare il String.Format(IFormatProvider, String, Object[]) metodo e fornire un ICustomFormatter implementazione. Nell'esempio seguente viene implementato il ICustomFormatter e IFormatProvider le interfacce per fornire stringhe booleane distinzione delle impostazioni cultura per l'inglese (Stati Uniti), francesi (Francia) e russe (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': верно

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

Il Boolean struttura implementa il IConvertible interfaccia. Di conseguenza, è possibile utilizzare il Convert classe per eseguire conversioni tra una Boolean valore e qualsiasi altro tipo primitivo in .NET Framework oppure è possibile chiamare il Boolean implementazioni esplicite della struttura. Tuttavia, le conversioni tra una Boolean e le operazioni seguenti tipi non sono supportati, pertanto i metodi di conversione corrispondente generano un InvalidCastException eccezione:

Tutte le conversioni da numeri a virgola mobile o integrale in valori booleani convertono valori diversi da zero a true e valori zero per false. L'esempio seguente illustra questo chiamando un overload selezionato 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

Durante la conversione da valori a virgola mobile in valori booleani, i metodi di conversione eseguono un confronto esatto con zero. Se il valore a virgola mobile ha perso la precisione, il risultato può essere imprevisto. Come illustrato nell'esempio seguente, in cui un Double variabile il cui valore deve essere zero viene convertito in un valore booleano. Come illustrato nell'esempio, il risultato è true poiché ripetuti aggiunte di 0,2 hanno comportato una perdita di precisione.

Durante la conversione da valore booleano in valori numerici, i metodi di conversione di Convert classe convert true su 1 e false su 0. Tuttavia, le funzioni di conversione di Visual Basic convertono true a entrambi 255 (per le conversioni in Byte valori) o -1 (per tutte le altre conversioni numeriche). L'esempio seguente converte true in valori numerici utilizzando un Convert (metodo) e, nel caso dell'esempio di Visual Basic, utilizzando l'operatore di conversione di Visual Basic del linguaggio personalizzati.

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

Per le conversioni da Boolean valori stringa, vedere il la formattazione di valori booleani sezione. Per le conversioni da stringhe a Boolean valori, vedere il analisi valori booleani sezione.

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

L'esempio seguente usa il Parse e TryParse metodi per analizzare un numero di stringhe. Si noti che solo gli equivalenti 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'

Se per la programmazione in Visual Basic, è possibile utilizzare il CBool funzione per convertire la rappresentazione di stringa di un numero in un valore booleano. "0" viene convertito in false, mentre la rappresentazione di stringa di qualsiasi valore diverso da zero viene convertita in true. Se non si programma in Visual Basic, è necessario convertire la stringa numerica in un numero prima di convertirlo in un valore booleano. Nell'esempio seguente questa condizione è illustrata la conversione di una matrice di interi di 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

Perché i valori booleani sono true o false, è necessario chiamare in modo esplicito il CompareTo (metodo), che indica se un'istanza è maggiore di, minore di, o uguale al valore specificato. In genere, per confrontare due variabili booleane, la chiamata di Equals metodo oppure utilizzare l'operatore di uguaglianza del linguaggio.

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

if (booleanValue) {

e

using System;

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

      foreach (var hasServiceCharge in hasServiceCharges) {
         Decimal total = subtotal + shippingCharge + 
                                (hasServiceCharge ? serviceCharge : 0);
         Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.", 
                           total, hasServiceCharge);                       
      }
   }
}
// The example displays output like the following:
//       hasServiceCharge = True: The total is $128.12.
//       hasServiceCharge = False: The total is $123.12.

sono equivalenti, mentre la seconda è più compatto. Tuttavia, entrambe le tecniche offrono prestazioni simili.

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

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

Bit di ordine inferiore del byte viene utilizzato per rappresentare il valore. Rappresenta un valore pari a 1 true; il valore 0 rappresenta false.

System_CAPS_warningAvviso

È possibile utilizzare il System.Collections.Specialized.BitVector32 struttura per utilizzare i set di valori booleani.

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

L'esempio seguente chiama il BitConverter.GetBytes metodo per convertire un valore booleano per la rappresentazione binaria e visualizza i singoli bit di valore e viene quindi chiamato il BitConverter.ToBoolean per ripristinare il valore dalla relativa 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

Questa sezione illustra i valori booleani come vengono usate in App. La prima sezione viene illustrato l'uso come un flag. La seconda viene illustrato l'utilizzo per operazioni aritmetiche.

Variabili booleane utilizzate più frequentemente come flag, per segnalare la presenza o assenza di una determinata condizione. Ad esempio, nel String.Compare(String, String, Boolean) metodo, il parametro finale, ignoreCase, è un flag che indica se il confronto di due stringhe è tra maiuscole e minuscole (ignoreCase è true) o distinzione maiuscole/minuscole (ignoreCase è false). Il valore del flag può quindi essere valutato in un'istruzione condizionale.

L'esempio seguente usa un'applicazione console semplice per illustrare l'utilizzo di variabili booleane come flag. L'applicazione accetta parametri della riga di comando che consentono di output essere reindirizzato a un file specificato (il /f passare), e che consentono di output da inviare a un file specificato sia nella console (il /b switch). L'app definisce un contrassegno denominato isRedirected per indicare se viene inviato a un file di output e un flag denominato isBoth per indicare che l'output deve essere inviato alla 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");
   }
}

Un valore booleano a volte viene utilizzato per indicare la presenza di una condizione che attiva un calcolo matematico. Ad esempio, un hasShippingCharge variabile potrebbe essere utilizzato come un flag che indica se aggiungere le spese di spedizione per un periodo di fatturazione.

Perché un'operazione con un false valore non ha alcun effetto sul risultato di un'operazione, non è necessario convertire il valore booleano in un valore integrale da utilizzare per l'operazione matematica. In alternativa, è possibile utilizzare la logica condizionale.

Nell'esempio seguente calcola una quantità che include un subtotale, spese di spedizione e un addebito assistenza facoltativo. Il hasServiceCharge variabile determina se viene applicato l'addebito di servizio. Invece di conversione hasServiceCharge a un valore numerico e moltiplicandolo per la quantità di addebito di assistenza, l'esempio Usa la logica condizionale per aggiungere la quantità di addebito assistenza, se 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.

Durante il marshalling dei tipi di dati di base a COM è in genere semplice, il Boolean tipo di dati è un'eccezione. È possibile applicare il MarshalAsAttribute attributo per effettuare il marshalling di Boolean tipo per qualsiasi rappresentazione seguente:

Tipo di enumerazione

Formato non gestito

UnmanagedType.Bool

Un valore integer a 4 byte, in cui qualsiasi valore diverso da zero rappresenta true e 0 rappresenta false. Questo è il formato predefinito di un Boolean campo in una struttura e di un Boolean chiamate di parametro in platform invoke.

UnmanagedType.U1

Un valore integer a 1 byte, dove 1 rappresenta true e 0 rappresenta false.

UnmanagedType.VariantBool

Un valore integer a 2 byte, dove -1 rappresenta true e 0 rappresenta false. Questo è il formato predefinito di un Boolean parametro nelle chiamate di interoperabilità COM.

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1

Tutti i membri di questo tipo sono thread-safe. I membri che apparentemente modificano lo stato dell'istanza è in realtà restituiscono una nuova istanza inizializzata con il nuovo valore. Come con qualsiasi altro tipo, lettura e scrittura in una variabile condivisa che contiene un'istanza di questo tipo deve essere protetto da un blocco per garantire la thread safety.

Torna all'inizio
Mostra: