Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Struttura Boolean

Rappresenta (true o false) un valore booleano.

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

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

Il tipo Boolean espone i seguenti membri.

  NomeDescrizione
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreCompareTo(Boolean)Confronta questa istanza con un oggetto Boolean specificato e restituisce un valore intero che indica la relazione reciproca.
Metodo pubblicoSupportato da XNA FrameworkCompareTo(Object)Confronta l'istanza con un oggetto specificato e restituisce un valore intero che indica la relazione reciproca.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEquals(Boolean)Restituisce un valore che indica se l'istanza è uguale a un oggetto specificato Boolean.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEquals(Object)Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato. (Esegue l'override di ValueType.Equals(Object)).
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetHashCode Restituisce il codice hash per l'istanza corrente. (Esegue l'override di ValueType.GetHashCode()).
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetType Ottiene il Type dell'istanza corrente. (Ereditato da Object)
Metodo pubblicoSupportato da XNA FrameworkGetTypeCodeRestituisce l'oggetto TypeCode del tipo di valore Boolean.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreParseConverte la rappresentazione di stringa specificata di un valore logico nell'equivalente Boolean, o genera un'eccezione se la stringa non è uguale al valore di Boolean.TrueString o Boolean.FalseString.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToString()Converte il valore dell'istanza corrente nella rappresentazione in forma di stringa equivalente ("True" o "False"). (Esegue l'override di ValueType.ToString()).
Metodo pubblicoSupportato da XNA FrameworkToString(IFormatProvider)Converte il valore dell'istanza corrente nella rappresentazione in forma di stringa equivalente ("True" o "False").
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreTryParseTenta di convertire la rappresentazione in forma di stringa specificata di un valore logico nell’equivalente Boolean. Un valore restituito indica se la conversione è riuscita o meno.
In alto

  NomeDescrizione
Campo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreFalseStringRappresenta un valore Boolean false come una stringa. Questo è un campo di sola lettura.
Campo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreTrueStringRappresenta un valore booleano true come stringa. Questo è un campo di sola lettura.
In alto

  NomeDescrizione
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIComparable.CompareToInfrastruttura. Confronta l'istanza corrente con un altro oggetto dello stesso tipo e restituisce un numero intero che indica se l'istanza corrente precede, segue, oppure si trova nella stessa posizione nell'ordinamento rispetto all'altro oggetto.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToBooleanInfrastruttura. Per una descrizione di questo membro, vedere il metodo IConvertible.ToBoolean.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToByteInfrastruttura. Per una descrizione di questo membro, vedere IConvertible.ToByte.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToCharInfrastruttura. Questa conversione non è supportata. Il tentativo di utilizzare questo metodo genera un'eccezione InvalidCastException.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToDateTimeInfrastruttura. Questa conversione non è supportata. Il tentativo di utilizzare questo metodo genera un'eccezione InvalidCastException.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToDecimalInfrastruttura. Per una descrizione di questo membro, vedere IConvertible.ToDecimal.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToDoubleInfrastruttura. Per una descrizione di questo membro, vedere IConvertible.ToDouble.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToInt16Infrastruttura. Per una descrizione di questo membro, vedere IConvertible.ToInt16.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToInt32Infrastruttura. Per una descrizione di questo membro, vedere IConvertible.ToInt32.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToInt64Infrastruttura. Per una descrizione di questo membro, vedere IConvertible.ToInt64.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToSByteInfrastruttura. Per una descrizione di questo membro, vedere IConvertible.ToSByte.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToSingleInfrastruttura. Per una descrizione di questo membro, vedere IConvertible.ToSingle.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToTypeInfrastruttura. Per una descrizione di questo membro, vedere il metodo IConvertible.ToType.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToUInt16Infrastruttura. Per una descrizione di questo membro, vedere IConvertible.ToUInt16.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToUInt32Infrastruttura. Per una descrizione di questo membro, vedere IConvertible.ToUInt32.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToUInt64Infrastruttura. Per una descrizione di questo membro, vedere IConvertible.ToUInt64.
In alto

Un'istanza di Boolean può avere uno dei due valori: true, o false.

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

Nelle sezioni seguenti vengono descritte queste attività e altri dettagli di utilizzo:

Valori booleani di formattazione
Conversione da e in valori boolean
Valori booleani di traccia
Confrontare i valori boolean
Utilizzo di valori boolean come valori binari
Esecuzione di operazioni con i valori boolean

Valori booleani di formattazione

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

Utilizzare il metodo di ToString per convertire valori boolean in stringhe. La struttura booleana include due overload di ToString : il metodo senza parametri di ToString() e il metodo di ToString(IFormatProvider), che include un parametro che la formattazione dei controlli. Tuttavia, poiché questo parametro viene ignorato, le due stringhe identiche dei prodotti di overload. Il metodo di ToString(IFormatProvider) non supporta la formattazione dipendente dalle impostazioni cultura.

Nell'esempio seguente viene illustrata la formattazione con il metodo di ToString. Si noti che nell'esempio viene utilizzata la funzionalità di formattazione composta, pertanto il metodo di ToString 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é la struttura di Boolean può contenere solo due valori, è facile aggiungere formattazione personalizzata. Per la formattazione personalizzata semplice in cui altri valori letterali stringa vengono sostituiti da "true" e "False", è possibile utilizzare tutte le funzionalità di valutazione condizionale supportato dal linguaggio, come operatore condizionale in c# o Se l'operatore in Visual Basic. Nell'esempio utilizza questa tecnica per formattare valori di Boolean come "sì" 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 le operazioni di formattazione personalizzata più complesse, quali la formattazione dipendente dalle impostazioni cultura, è possibile chiamare il metodo di String.Format(IFormatProvider, String, Object[]) e fornire un'implementazione di ICustomFormatter. Nell'esempio implementa le interfacce di IFormatProvider e di ICustomFormatter per fornire stringhe booleane dipendenti dalle impostazioni cultura per le impostazioni cultura inglesi (Stati Uniti), della lingua francese (Francia) e russa (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 le impostazioni cultura specifiche.

Conversione da e in valori boolean

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

Tutte le conversioni da integrale o da numeri a virgola mobile ai valori boolean convertono valori diversi da zero in true e i valori zeri in false. Nell'esempio seguente viene illustrato questo chiamando gli overload selezionati della classe di Convert.ToBoolean.


using System;

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


Quando si effettua la conversione da valori a virgola mobile in valori boolean, i metodi di conversione eseguito un confronto esatto con zero. Se il valore a virgola mobile non è più in precisione, il risultato può essere imprevisto. Tale situazione è illustrata nell'esempio seguente, in cui una variabile di Double il cui valore deve essere zero viene convertita in un valore boolean. Come illustrato nell'esempio, il risultato è true perché le aggiunte ripetute di 0,2 hanno provocato una perdita di precisione.

Nella conversione da boolean in valori numerici, i metodi di conversione della classe di Convert conversione true in 1 e false in 0. Tuttavia, le funzioni di conversione di Visual Basic possono essere convertiti in true 255 (per le conversioni i valori di Byte ) o -1 (per tutte le altre conversioni numeriche). Nell'esempio riportato true in valori numerici utilizzando un metodo di Convert e, in caso di esempio di Visual Basic, utilizzando il proprio operatore di conversione del linguaggio 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


Per le conversioni da Boolean ai valori stringa, vedere la sezione di Valori booleani di formattazione. Per le conversioni da stringa ai valori di Boolean, vedere la sezione di Valori booleani di traccia.

Valori booleani di traccia

La struttura di Boolean include due metodi, Parse e TryParsedi analisi statici, che convertono una stringa in un valore boolean. La rappresentazione di stringa di un valore booleano viene definita rispettivamente dagli equivalenti senza distinzione tra maiuscole e minuscole dei valori dei campi di FalseString e di TrueString, ovvero "true" e "False". Ovvero le sole stringhe che analizzano correttamente sono "true", "False", "true", "false", o di equivalente di lettere maiuscole e minuscole. Non è possibile analizzare correttamente le stringhe numeriche come "0 " o "1 ". Gli spazi vuoti iniziali o finali non sono considerati durante il confronto di stringhe.

Nell'esempio vengono utilizzati i metodi di TryParse e di Parse per analizzare una stringa di stringhe. Notare che solo gli equivalenti senza distinzione tra maiuscole e minuscole "true" e "False" possono essere analizzato 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 si sta programmando in Visual Basic, è possibile utilizzare la funzione di CBool per convertire la rappresentazione di stringa di un numero in un valore boolean. "0 " viene convertito in false e la rappresentazione di stringa del valore diverso da zero viene convertita in true. Se non si sta programmando in Visual Basic, è necessario convertire la stringa numerica in numero prima di convertirlo in un valore boolean. Nell'esempio seguente viene illustrato questo conversione di una matrice di integer in valori boolean.


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


Confrontare i valori boolean

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

Tuttavia, quando si desidera confrontare una variabile boolean con il valore boolean letterale true o false, non è necessario eseguire il confronto esplicito, in quanto il risultato di valutazione di valore booleano è il 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.


sia equivalente, mentre il secondo è più compatto. Tuttavia, entrambe le tecniche offrono prestazioni confrontabili.

Utilizzo di valori boolean come valori binari

Un valore boolean occupa un byte di memoria. Il bit meno significativi di byte consente di rappresentare il valore. Un valore 1 rappresenta true; un valore 0 rappresenta false.

Nota di avvisoAttenzione

È possibile utilizzare la struttura di System.Collections.Specialized.BitVector32 per utilizzare set di valori boolean.

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

Nell'esempio seguente viene chiamato il metodo di BitConverter.GetBytes per convertire un valore boolean nella relativa rappresentazione binaria e visualizzare i singoli bit di valore e quindi chiama il metodo di 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


Esecuzione di operazioni con i valori boolean

In questa sezione viene illustrato come valori booleani vengono utilizzati nelle applicazioni. La prima sezione viene illustrato l'utilizzo come flag. Il secondo viene illustrato il relativo utilizzo per le operazioni aritmetiche.

a28wyd50.collapse_all(it-it,VS.110).gifValori boolean come flag

Le variabili boolean vengono utilizzate come flag, segnalare la presenza o l'assenza di determinate condizioni. Ad esempio, nel metodo di String.Compare(String, String, Boolean), il parametro finale, ignoreCase, è un flag che indica se il confronto di due stringhe viene eseguito senza distinzione tra maiuscole e minuscole (ignoreCase è true) o con distinzione tra maiuscole e minuscole (ignoreCase è false). Il valore del flag può essere valutati in un'istruzione condizionale.

Nell'esempio seguente viene utilizzata una semplice applicazione console per illustrare l'utilizzo di variabili booleane come flag. L'applicazione accetta parametri della riga di comando che consentono di output per reindirizzare a un file specificato (l'opzione /f ) e l'invio di output da essere inviato a un file specificato nella console (l'opzione /b ). L'applicazione definisce un flag denominato isRedirected per indicare se l'output deve essere inviato a un file e un flag denominato isBoth da indicare che restituisce deve essere inviati 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");
   }
}


a28wyd50.collapse_all(it-it,VS.110).gifValori booleani e operazioni aritmetiche

Un valore boolean viene talvolta utilizzato per indicare la presenza di condizione che avvia un calcolo matematico. Ad esempio, una variabile di hasShippingCharge può fungere da flag indicare se aggiungere le spese di trasporto a un importo di distinta.

Poiché un'operazione con un valore di false non ha effetto sul risultato di un'operazione, non è necessario convertire il valore boolean in un valore integrale in use in un'operazione matematica. Al contrario, è possibile utilizzare la logica condizionale.

Nell'esempio seguente viene calcolato un importo costituito da un subtotale, una tassa di trasporto e di una spesa per i servizi facoltativa. La variabile di hasServiceCharge determina se la spesa per i servizi applica. Anziché la conversione di hasServiceCharge in valori numerici e la moltiplicazione per la quantità della spesa per i servizi, la logica condizionaleesempio viene utilizzato per aggiungere la quantità della spesa per i servizi 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.


.NET Framework

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Libreria di classi portabile

Supportato in: Libreria di classi portabile

.NET per applicazioni Windows Store

Supportato in: Windows 8

.NET per applicazioni Windows Phone

Supportato in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

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

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft