Boolean Boolean Boolean Boolean Struct

Definition

Rappresenta un valore booleano (true o false). Represents a Boolean (true or false) value.

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

Remarks

Oggetto Boolean istanza può avere uno dei due valori: true, o false.A Boolean instance can have either of two values: true, or false.

Il Boolean struttura fornisce metodi che supportano le attività seguenti:The Boolean structure provides methods that support the following tasks:

Le sezioni seguenti illustrano queste attività e altri dettagli di utilizzo:The following sections explain these tasks and other usage details:

Formattazione di valori booleani Formatting Boolean values
Conversione da e verso i valori booleani Converting to and from Boolean values
Analisi dei valori booleani Parsing Boolean values
Confronto di valori booleani Comparing Boolean values
Utilizzo di valori booleani come valori binari Working with Booleans as binary values
Esecuzione di operazioni con valori booleani Performing operations with Boolean values
Interoperabilità e valori booleaniBooleans and Interop

Formattazione di valori booleaniFormatting Boolean values

Rappresentazione di stringa di un Boolean può essere "True" per un true valore o "False" per un false valore.The string representation of a Boolean is either "True" for a true value or "False" for a false value. Rappresentazione di stringa di un Boolean valore è definito da sola lettura TrueString e FalseString campi.The string representation of a Boolean value is defined by the read-only TrueString and FalseString fields.

Si utilizza il ToString metodo per convertire i valori booleani in stringhe.You use the ToString method to convert Boolean values to strings. La struttura booleana sono inclusi due ToString Overload: senza parametri ToString() metodo e il ToString(IFormatProvider) metodo, che include un parametro che controlla la formattazione.The Boolean structure includes two ToString overloads: the parameterless ToString() method and the ToString(IFormatProvider) method, which includes a parameter that controls formatting. Tuttavia, poiché questo parametro viene ignorato, i due overload producono stringhe identiche.However, because this parameter is ignored, the two overloads produce identical strings. Il ToString(IFormatProvider) (metodo) non supporta la formattazione dipendente dalle impostazioni cultura.The ToString(IFormatProvider) method does not support culture-sensitive formatting.

L'esempio seguente illustra la formattazione con la ToString (metodo).The following example illustrates formatting with the ToString method. Si noti che l'esempio Usa la formattazione composita funzionalità, pertanto la ToString viene chiamato in modo implicito.Note that the example uses the composite formatting feature, so the ToString method is called implicitly.

using System;

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

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

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

Poiché il Boolean struttura può avere solo due valori, è facile aggiungere la formattazione personalizzata.Because the Boolean structure can have only two values, it is easy to add custom formatting. Per semplici formattazione personalizzata in cui un'altra stringa vengono sostituiti con i valori letterali per "True" e "False", è possibile usare qualsiasi funzionalità di valutazione condizionale supportato dal linguaggio di, ad esempio la operatore condizionale in c# o il Se operatore in Visual Basic.For simple custom formatting in which other string literals are substituted for "True" and "False", you can use any conditional evaluation feature supported by your language, such as the conditional operator in C# or the If operator in Visual Basic. L'esempio seguente usa questa tecnica per formattare Boolean valori come "Sì" e "No" anziché "True" e "False".The following example uses this technique to format Boolean values as "Yes" and "No" rather than "True" and "False".

using System;

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

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

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

Per più complesse operazioni di formattazione personalizzate, tra cui formattazione dipendente dalle impostazioni cultura, è possibile chiamare il String.Format(IFormatProvider, String, Object[]) metodo e forniscono un ICustomFormatter implementazione.For more complex custom formatting operations, including culture-sensitive formatting, you can call the String.Format(IFormatProvider, String, Object[]) method and provide an ICustomFormatter implementation. L'esempio seguente implementa il ICustomFormatter e IFormatProvider interfacce per fornire le stringhe booleane distinzione delle impostazioni cultura per l'inglese (Stati Uniti), francesi (Francia) e russe (Russia).The following example implements the ICustomFormatter and IFormatProvider interfaces to provide culture-sensitive Boolean strings for the English (United States), French (France), and Russian (Russia) cultures.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "", "en-US", "fr-FR", "ru-RU" };
      foreach (var cultureName in cultureNames) {
         bool value = true;
         CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
         BooleanFormatter formatter = new BooleanFormatter(culture);
         
         String result = String.Format(formatter, "Value for '{0}': {1}", culture.Name, value);
         Console.WriteLine(result);
      }
   }
}

public class BooleanFormatter : ICustomFormatter, IFormatProvider
{   
   private CultureInfo culture;
   
   public BooleanFormatter() : this(CultureInfo.CurrentCulture)
   { }
   
   public BooleanFormatter(CultureInfo culture)
   {
      this.culture = culture; 
   }
   
   public Object GetFormat(Type formatType)
   { 
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }
   
   public String Format(String fmt, Object arg, IFormatProvider formatProvider)
   { 
      // Exit if another format provider is used.
      if (! formatProvider.Equals(this)) return null;
      
      // Exit if the type to be formatted is not a Boolean
      if (! (arg is Boolean)) return null;
      
      bool value = (bool) arg;
      switch (culture.Name) {
         case "en-US":
            return value.ToString();
         case "fr-FR":
            if (value) 
               return "vrai";
            else
               return "faux";
         case "ru-RU":
            if (value)
               return "верно";
            else
               return "неверно";
         default:
            return value.ToString();  
      }
   }
}
// The example displays the following output:
//       Value for '': True
//       Value for 'en-US': True
//       Value for 'fr-FR': vrai
//       Value for 'ru-RU': верно
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "", "en-US", "fr-FR", "ru-RU" }
      For Each cultureName In cultureNames
         Dim value As Boolean = True
         Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
         Dim formatter As New BooleanFormatter(culture)
         
         Dim result As String = String.Format(formatter, "Value for '{0}': {1}", culture.Name, value)
         Console.WriteLine(result)
      Next
   End Sub
End Module

Public Class BooleanFormatter 
   Implements ICustomFormatter, IFormatProvider
   
   Private culture As CultureInfo
   
   Public Sub New()
      Me.New(CultureInfo.CurrentCulture)
   End Sub
   
   Public Sub New(culture As CultureInfo)
      Me.culture = culture 
   End Sub
   
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If                
   End Function
   
   Public Function Format(fmt As String, arg As Object, 
                          formatProvider As IFormatProvider) As String _
                   Implements ICustomFormatter.Format
      ' Exit if another format provider is used.
      If Not formatProvider.Equals(Me) Then Return Nothing
      
      ' Exit if the type to be formatted is not a Boolean
      If Not TypeOf arg Is Boolean Then Return Nothing
      
      Dim value As Boolean = CBool(arg)
      Select culture.Name
         Case "en-US"
            Return value.ToString()
         Case "fr-FR"
            If value Then
               Return "vrai"
            Else
               Return "faux"
            End If      
         Case "ru-RU"
            If value Then
               Return "верно"
            Else
               Return "неверно"
            End If   
         Case Else
            Return value.ToString()  
      End Select
   End Function
End Class
' The example displays the following output:
'          Value for '': True
'          Value for 'en-US': True
'          Value for 'fr-FR': vrai
'          Value for 'ru-RU': верно

Facoltativamente, è possibile usare file di risorse per definire le stringhe booleane di impostazioni cultura specifiche.Optionally, you can use resource files to define culture-specific Boolean strings.

Conversione da e verso i valori booleaniConverting to and from Boolean values

Il Boolean struttura implementa il IConvertible interfaccia.The Boolean structure implements the IConvertible interface. Di conseguenza, è possibile usare la Convert classe per eseguire conversioni tra una Boolean valore e altri tipi primitivi in .NET Framework, oppure è possibile chiamare il Boolean implementazioni esplicite della struttura.As a result, you can use the Convert class to perform conversions between a Boolean value and any other primitive type in the .NET Framework, or you can call the Boolean structure's explicit implementations. Tuttavia, le conversioni tra una Boolean e le seguenti tipi non sono supportati, in modo che i metodi di conversione corrispondenti generano un InvalidCastException eccezione:However, conversions between a Boolean and the following types are not supported, so the corresponding conversion methods throw an InvalidCastException exception:

Tutte le conversioni da numeri a virgola mobile o integrale in valori booleani convertono valori diverso da zero in true e valori zero per false.All conversions from integral or floating-point numbers to Boolean values convert non-zero values to true and zero values to false. L'esempio seguente illustra questo chiamando selezionato gli overload del Convert.ToBoolean classe.The following example illustrates this by calling selected overloads of the Convert.ToBoolean class.

using System;

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

La conversione da valori a virgola mobile a valori booleani, i metodi di conversione eseguono un confronto esatto con zero.When converting from floating-point values to Boolean values, the conversion methods perform an exact comparison with zero. Se il valore a virgola mobile ha perso precisione, il risultato può essere imprevisto.If the floating-point value has lost precision, the result can be unexpected. Questa operazione viene illustrata nell'esempio seguente, in cui un Double variabile il cui valore deve essere zero viene convertita in un valore booleano.This is illustrated in the following example, in which a Double variable whose value should be zero is converted to a Boolean value. Come illustrato nell'esempio, il risultato è true poiché ripetuti aggiunte di 0,2 hanno comportato una perdita di precisione.As the example shows, the result is true because repeated additions of 0.2 have resulted in a loss of precision.

La conversione da valore booleano a valori numerici, i metodi di conversione del Convert classe convert true su 1 e false su 0.When converting from Boolean to numeric values, the conversion methods of the Convert class convert true to 1 and false to 0. Tuttavia, di convertire le funzioni di conversione di Visual Basic true entrambi 255 (per le conversioni in Byte valori) o -1 (per tutte le altre conversioni numeriche).However, Visual Basic conversion functions convert true to either 255 (for conversions to Byte values) or -1 (for all other numeric conversions). L'esempio seguente converte true in valori numerici usando un Convert (metodo) e, nel caso dell'esempio di Visual Basic, usando l'operatore di conversione di Visual Basic del linguaggio personalizzati.The following example converts true to numeric values by using a Convert method, and, in the case of the Visual Basic example, by using the Visual Basic language's own conversion operator.

using System;

public class Example
{
   public static void Main()
   {
      bool flag = true;
      
      byte byteValue;   
      byteValue = Convert.ToByte(flag);
      Console.WriteLine("{0} -> {1}", flag, byteValue);         
      
      sbyte sbyteValue;
      sbyteValue = Convert.ToSByte(flag);
      Console.WriteLine("{0} -> {1}", flag, sbyteValue);         

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

      int intValue;
      intValue = Convert.ToInt32(flag);
      Console.WriteLine("{0} -> {1}", flag, intValue);         
   }
}
// The example displays the following output:
//       True -> 1
//       True -> 1
//       True -> 1
//       True -> 1
Module Example
   Public Sub Main()
      Dim flag As Boolean = true
      
      Dim byteValue As Byte   
      byteValue = Convert.ToByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, byteValue, 
                                            byteValue.GetType().Name)         
      byteValue = CByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, byteValue, 
                                            byteValue.GetType().Name)         
      
      Dim sbyteValue As SByte
      sbyteValue = Convert.ToSByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue, 
                                            sbyteValue.GetType().Name)         
      sbyteValue = CSByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue, 
                                            sbyteValue.GetType().Name)         

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

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

Per le conversioni da Boolean valori di stringa, vedere la formattazione di valori booleani sezione.For conversions from Boolean to string values, see the Formatting Boolean Values section. Conversioni di stringhe Boolean valori, vedere la l'analisi di valori booleani sezione.For conversions from strings to Boolean values, see the Parsing Boolean Values section.

Analisi dei valori booleaniParsing Boolean values

Il Boolean struttura include due metodi di analisi statici, Parse e TryParse, che converte una stringa in un valore booleano.The Boolean structure includes two static parsing methods, Parse and TryParse, that convert a string to a Boolean value. La rappresentazione di stringa di un valore booleano è definita dagli equivalenti dei valori di distinzione tra maiuscole e le TrueString e FalseString campi che sono "True" e "False", rispettivamente.The string representation of a Boolean value is defined by the case-insensitive equivalents of the values of the TrueString and FalseString fields, which are "True" and "False", respectively. In altre parole, il solo stringhe che vengono analizzate correttamente sono "True", "False", "true", "false" o alcuni equivalente di maiuscole e minuscole.In other words, the only strings that parse successfully are "True", "False", "true", "false", or some mixed-case equivalent. Non è possibile analizzare le stringhe numeriche, ad esempio "0" o "1".You cannot successfully parse numeric strings such as "0" or "1". Caratteri spazi vuoti iniziali o finali non vengono considerati quando si esegue il confronto di stringhe.Leading or trailing white-space characters are not considered when performing the string comparison.

L'esempio seguente usa il Parse e TryParse metodi per analizzare un numero di stringhe.The following example uses the Parse and TryParse methods to parse a number of strings. Si noti che solo gli equivalenti di "True" e "False" tra maiuscole e minuscole possono essere analizzati correttamente.Note that only the case-insensitive equivalents of "True" and "False" can be successfully parsed.

using System;

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

Se per la programmazione in Visual Basic, è possibile usare il CBool funzione per convertire la rappresentazione di stringa di un numero in un valore booleano.If you are programming in Visual Basic, you can use the CBool function to convert the string representation of a number to a Boolean value. "0" viene convertito in false, e la rappresentazione di stringa di qualsiasi valore diverso da zero viene convertita in true."0" is converted to false, and the string representation of any non-zero value is converted to true. Se non si programma in Visual Basic, è necessario convertire la stringa numerica in un numero prima di convertirlo in un valore booleano.If you are not programming in Visual Basic, you must convert your numeric string to a number before converting it to a Boolean. L'esempio seguente illustra questo eseguendo la conversione di una matrice di integer a valori booleani.The following example illustrates this by converting an array of integers to Boolean values.

using System;

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

Confronto di valori booleaniComparing Boolean values

Perché sono valori booleani true oppure false, non c'è motivo little chiamare in modo esplicito il CompareTo (metodo), indicante se un'istanza è maggiore, minore o uguale al valore specificato.Because Boolean values are either true or false, there is little reason to explicitly call the CompareTo method, which indicates whether an instance is greater than, less than, or equal to a specified value. In genere, per confrontare due variabili booleane, si chiama il Equals metodo oppure usare l'operatore di uguaglianza del linguaggio.Typically, to compare two Boolean variables, you call the Equals method or use your language's equality operator.

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.However, when you want to compare a Boolean variable with the literal Boolean value true or false, it is not necessary to do an explicit comparison, because the result of evaluating a Boolean value is that Boolean value. Ad esempio, le espressioniFor example, the expressions

if (booleanValue) {
If booleanValue Then

eand

using System;

public class Example
{
   public static void Main()
   {
      bool[] hasServiceCharges = { true, false };
      Decimal subtotal = 120.62m;
      Decimal shippingCharge = 2.50m;
      Decimal serviceCharge = 5.00m;
      
      foreach (var hasServiceCharge in hasServiceCharges) {
         Decimal total = subtotal + shippingCharge + 
                                (hasServiceCharge ? serviceCharge : 0);
         Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.", 
                           total, hasServiceCharge);                       
      }
   }
}
// The example displays output like the following:
//       hasServiceCharge = True: The total is $128.12.
//       hasServiceCharge = False: The total is $123.12.
Module Example
   Public Sub Main()
      Dim hasServiceCharges() As Boolean = { True, False }
      Dim subtotal As Decimal = 120.62d
      Dim shippingCharge As Decimal = 2.50d
      Dim serviceCharge As Decimal = 5.00d
      
      For Each hasServiceCharge In hasServiceCharges
         Dim total As Decimal = subtotal + shippingCharge + 
                                If(hasServiceCharge, serviceCharge, 0)
         Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.", 
                           total, hasServiceCharge)                       
      Next
   End Sub
End Module
' The example displays output like the following:
'       hasServiceCharge = True: The total is $128.12.
'       hasServiceCharge = False: The total is $123.12.

sono considerati equivalenti, ma il secondo sia più compatto.are equivalent, but the second is more compact. Tuttavia, entrambe le tecniche offrono prestazioni simili.However, both techniques offer comparable performance.

Utilizzo di valori booleani come valori binariWorking with Booleans as binary values

Valore booleano occupa un byte di memoria, come illustrato nell'esempio c# seguente.A Boolean value occupies one byte of memory, as the following C# example shows. L'esempio deve essere compilato con la /unsafe passare.The example must be compiled with the /unsafe switch.

using System;

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

public class Example
{
   public static void Main()
   {
      unsafe {
         BoolStruct b = new BoolStruct();
         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 meno significativi del byte viene utilizzato per rappresentare il relativo valore.The byte's low-order bit is used to represent its value. Rappresenta un valore pari a 1 true; il valore 0 rappresenta false.A value of 1 represents true; a value of 0 represents false.

Avviso

È possibile usare il System.Collections.Specialized.BitVector32 struttura per lavorare con i set di valori booleani.You can use the System.Collections.Specialized.BitVector32 structure to work with sets of Boolean values.

È possibile convertire un valore booleano nella relativa rappresentazione binaria chiamando il BitConverter.GetBytes(Boolean) (metodo).You can convert a Boolean value to its binary representation by calling the BitConverter.GetBytes(Boolean) method. Il metodo restituisce una matrice di byte con un singolo elemento.The method returns a byte array with a single element. Per ripristinare un valore booleano dalla relativa rappresentazione binaria, è possibile chiamare il BitConverter.ToBoolean(Byte[], Int32) (metodo).To restore a Boolean value from its binary representation, you can call the BitConverter.ToBoolean(Byte[], Int32) method.

L'esempio seguente chiama il BitConverter.GetBytes metodo per convertire un valore booleano per la rappresentazione binaria e consente di visualizzare i singoli bit di valore e a sua volta chiama il BitConverter.ToBoolean metodo per ripristinare il valore dalla relativa rappresentazione binaria.The following example calls the BitConverter.GetBytes method to convert a Boolean value to its binary representation and displays the individual bits of the value, and then calls the BitConverter.ToBoolean method to restore the value from its binary representation.

using System;

public class Example
{
   public static void Main()
   {
      bool[] flags = { true, false };
      foreach (var flag in flags) {
         // Get binary representation of flag.
         Byte value = BitConverter.GetBytes(flag)[0];
         Console.WriteLine("Original value: {0}", flag);
         Console.WriteLine("Binary value:   {0} ({1})", value, 
                           GetBinaryString(value));
         // Restore the flag from its binary representation.
         bool newFlag = BitConverter.ToBoolean( new Byte[] { value }, 0);
         Console.WriteLine("Restored value: {0}\n", flag);
      }
   }
   
   private static string GetBinaryString(Byte value)
   {
      String retVal = Convert.ToString(value, 2);
      return new String('0', 8 - retVal.Length) + retVal;
   }
}
// The example displays the following output:
//       Original value: True
//       Binary value:   1 (00000001)
//       Restored value: True
//       
//       Original value: False
//       Binary value:   0 (00000000)
//       Restored value: False
Module Example
   Public Sub Main()
      Dim flags() As Boolean = { True, False }
      For Each flag In flags
         ' Get binary representation of flag.
         Dim value As Byte = BitConverter.GetBytes(flag)(0)
         Console.WriteLine("Original value: {0}", flag)
         Console.WriteLine("Binary value:   {0} ({1})", value, 
                           GetBinaryString(value))
         ' Restore the flag from its binary representation.
         Dim newFlag As Boolean = BitConverter.ToBoolean( { value }, 0)
         Console.WriteLine("Restored value: {0}", flag)
         Console.WriteLine()
      Next
   End Sub
   
   Private Function GetBinaryString(value As Byte) As String
      Dim retVal As String = Convert.ToString(value, 2)
      Return New String("0"c, 8 - retVal.Length) + retVal
   End Function
End Module
' The example displays the following output:
'       Original value: True
'       Binary value:   1 (00000001)
'       Restored value: True
'       
'       Original value: False
'       Binary value:   0 (00000000)
'       Restored value: False

Esecuzione di operazioni con valori booleaniPerforming operations with Boolean values

Questa sezione illustra i valori booleani come vengono usati nelle app.This section illustrates how Boolean values are used in apps. La prima sezione viene illustrato l'uso come un flag.The first section discusses its use as a flag. La seconda viene illustrato l'utilizzo per operazioni aritmetiche.The second illustrates its use for arithmetic operations.

Valori booleani come flagBoolean values as flags

Le variabili booleane utilizzate più frequentemente come flag, per segnalare la presenza o assenza di una determinata condizione.Boolean variables are most commonly used as flags, to signal the presence or absence of some condition. Ad esempio, nel String.Compare(String, String, Boolean) metodo, l'ultimo parametro, ignoreCase, è un flag che indica se il confronto di due stringhe è tra maiuscole e minuscole (ignoreCase viene true) o distinzione maiuscole/minuscole (ignoreCase è false).For example, in the String.Compare(String, String, Boolean) method, the final parameter, ignoreCase, is a flag that indicates whether the comparison of two strings is case-insensitive (ignoreCase is true) or case-sensitive (ignoreCase is false). Il valore del flag può quindi essere valutato in un'istruzione condizionale.The value of the flag can then be evaluated in a conditional statement.

L'esempio seguente usa un'app console semplice per illustrare l'utilizzo di variabili booleane come flag.The following example uses a simple console app to illustrate the use of Boolean variables as flags. L'app accetta parametri della riga di comando che abilita output venga reindirizzato su un file specificato (il /f switch), e che consentono l'output da inviare a un file specificato sia nella console (il /b switch).The app accepts command-line parameters that enable output to be redirected to a specified file (the /f switch), and that enable output to be sent both to a specified file and to the console (the /b switch). L'app definisce un flag 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.The app defines a flag named isRedirected to indicate whether output is to be sent to a file, and a flag named isBoth to indicate that output should be sent to the console.

using System;
using System.IO;
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 aritmeticheBooleans and arithmetic operations

Valore booleano a volte consente di indicare la presenza di una condizione che attiva un calcolo matematico.A Boolean value is sometimes used to indicate the presence of a condition that triggers a mathematical calculation. Ad esempio, un hasShippingCharge variabile può essere usate come flag che indica se aggiungere le spese di spedizione per un importo della fattura.For example, a hasShippingCharge variable might serve as a flag to indicate whether to add shipping charges to an invoice amount.

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 nell'operazione matematica.Because an operation with a false value has no effect on the result of an operation, it is not necessary to convert the Boolean to an integral value to use in the mathematical operation. In alternativa, è possibile usare per la logica condizionale.Instead, you can use conditional logic.

Nell'esempio seguente calcola una quantità che è costituito da un subtotale, le spese di spedizione e un addebito per il servizio facoltativo.The following example computes an amount that consists of a subtotal, a shipping charge, and an optional service charge. Il hasServiceCharge variabile determina se viene applicato l'addebito per il servizio.The hasServiceCharge variable determines whether the service charge is applied. Anziché convertire hasServiceCharge a un valore numerico e moltiplicandolo per la quantità dell'addebito per il servizio, l'esempio Usa la logica condizionale per aggiungere la quantità di addebito per il servizio se è applicabile.Instead of converting hasServiceCharge to a numeric value and multiplying it by the amount of the service charge, the example uses conditional logic to add the service charge amount if it is applicable.

using System;

public class Example
{
   public static void Main()
   {
      bool[] hasServiceCharges = { true, false };
      Decimal subtotal = 120.62m;
      Decimal shippingCharge = 2.50m;
      Decimal serviceCharge = 5.00m;
      
      foreach (var hasServiceCharge in hasServiceCharges) {
         Decimal total = subtotal + shippingCharge + 
                                (hasServiceCharge ? serviceCharge : 0);
         Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.", 
                           total, hasServiceCharge);                       
      }
   }
}
// The example displays output like the following:
//       hasServiceCharge = True: The total is $128.12.
//       hasServiceCharge = False: The total is $123.12.
Module Example
   Public Sub Main()
      Dim hasServiceCharges() As Boolean = { True, False }
      Dim subtotal As Decimal = 120.62d
      Dim shippingCharge As Decimal = 2.50d
      Dim serviceCharge As Decimal = 5.00d
      
      For Each hasServiceCharge In hasServiceCharges
         Dim total As Decimal = subtotal + shippingCharge + 
                                If(hasServiceCharge, serviceCharge, 0)
         Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.", 
                           total, hasServiceCharge)                       
      Next
   End Sub
End Module
' The example displays output like the following:
'       hasServiceCharge = True: The total is $128.12.
'       hasServiceCharge = False: The total is $123.12.

Interoperabilità e valori booleaniBooleans and interop

Mentre il marshalling dei tipi di dati di base a COM è generalmente semplice, il Boolean tipo di dati è un'eccezione.While marshaling base data types to COM is generally straightforward, the Boolean data type is an exception. È possibile applicare il MarshalAsAttribute attributo per effettuare il marshalling di Boolean tipo a una delle rappresentazioni di seguenti:You can apply the MarshalAsAttribute attribute to marshal the Boolean type to any of the following representations:

Tipo di enumerazioneEnumeration type Formato non gestitoUnmanaged format
UnmanagedType.Bool Un valore intero a 4 byte, dove rappresenta qualsiasi valore diverso da zero true e 0 rappresenta false.A 4-byte integer value, where any nonzero value represents true and 0 represents false. Questo è il formato predefinito di un Boolean campo in una struttura e di un Boolean parametro piattaforma di richiamare le chiamate.This is the default format of a Boolean field in a structure and of a Boolean parameter in platform invoke calls.
UnmanagedType.U1 Un valore integer a 1 byte, dove 1 rappresenta true e 0 rappresenta false.A 1-byte integer value, where the 1 represents true and 0 represents false.
UnmanagedType.VariantBool Un valore integer a 2 byte, dove rappresenta -1 true e 0 rappresenta false.A 2-byte integer value, where -1 represents true and 0 represents false. Questo è il formato predefinito di un Boolean parametro nelle chiamate all'interoperabilità COM.This is the default format of a Boolean parameter in COM interop calls.

Fields

FalseString FalseString FalseString FalseString

Rappresenta un valore booleano false sotto forma di stringa. Represents the Boolean value false as a string. Questo campo è di sola lettura. This field is read-only.

TrueString TrueString TrueString TrueString

Rappresenta un valore booleano true sotto forma di stringa. Represents the Boolean value true as a string. Questo campo è di sola lettura. This field is read-only.

Methods

CompareTo(Boolean) CompareTo(Boolean) CompareTo(Boolean) CompareTo(Boolean)

Confronta questa istanza con un oggetto Boolean specificato e restituisce un intero che indica la relazione reciproca. Compares this instance to a specified Boolean object and returns an integer that indicates their relationship to one another.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

Confronta l'istanza con un oggetto specificato e restituisce un valore intero che indica la relazione reciproca. Compares this instance to a specified object and returns an integer that indicates their relationship to one another.

Equals(Boolean) Equals(Boolean) Equals(Boolean) Equals(Boolean)

Restituisce un valore che indica se questa istanza è uguale a un oggetto Boolean specificato. Returns a value indicating whether this instance is equal to a specified Boolean object.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato. Returns a value indicating whether this instance is equal to a specified object.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Restituisce il codice hash per l'istanza. Returns the hash code for this instance.

GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

Restituisce il codice del tipo per il tipo di valore Boolean. Returns the type code for the Boolean value type.

Parse(ReadOnlySpan<Char>) Parse(ReadOnlySpan<Char>) Parse(ReadOnlySpan<Char>) Parse(ReadOnlySpan<Char>)
Parse(String) Parse(String) Parse(String) Parse(String)

Converte la rappresentazione di stringa specificata di un valore logico nel relativo valore Boolean equivalente. Converts the specified string representation of a logical value to its Boolean equivalent.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

Converte il valore dell'istanza corrente nella rappresentazione di stringa equivalente ("True" o "False"). Converts the value of this instance to its equivalent string representation (either "True" or "False").

ToString() ToString() ToString() ToString()

Converte il valore dell'istanza corrente nella rappresentazione di stringa equivalente ("True" o "False"). Converts the value of this instance to its equivalent string representation (either "True" or "False").

TryFormat(Span<Char>, Int32) TryFormat(Span<Char>, Int32) TryFormat(Span<Char>, Int32) TryFormat(Span<Char>, Int32)
TryParse(ReadOnlySpan<Char>, Boolean) TryParse(ReadOnlySpan<Char>, Boolean) TryParse(ReadOnlySpan<Char>, Boolean) TryParse(ReadOnlySpan<Char>, Boolean)
TryParse(String, Boolean) TryParse(String, Boolean) TryParse(String, Boolean) TryParse(String, Boolean)

Prova a convertire la rappresentazione di stringa specificata di un valore logico nell'oggetto Boolean equivalente. Tries to convert the specified string representation of a logical value to its Boolean equivalent. Un valore restituito indica se la conversione è riuscita o meno. A return value indicates whether the conversion succeeded or failed.

Explicit Interface Implementations

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)
IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider)

Per una descrizione di questo membro, vedere ToBoolean(IFormatProvider). For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

Per una descrizione di questo membro, vedere ToByte(IFormatProvider). For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

Questa conversione non è supportata. This conversion is not supported. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. Attempting to use this method throws an InvalidCastException.

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

Questa conversione non è supportata. This conversion is not supported. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. Attempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

Per una descrizione di questo membro, vedere ToDecimal(IFormatProvider). For a description of this member, see ToDecimal(IFormatProvider)..

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

Per una descrizione di questo membro, vedere ToDouble(IFormatProvider). For a description of this member, see ToDouble(IFormatProvider)..

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

Per una descrizione di questo membro, vedere ToInt16(IFormatProvider). For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

Per una descrizione di questo membro, vedere ToInt32(IFormatProvider). For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

Per una descrizione di questo membro, vedere ToInt64(IFormatProvider). For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

Per una descrizione di questo membro, vedere ToSByte(IFormatProvider). For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

Per una descrizione di questo membro, vedere ToSingle(IFormatProvider). For a description of this member, see ToSingle(IFormatProvider)..

IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider)

Per una descrizione di questo membro, vedere ToType(Type, IFormatProvider). For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

Per una descrizione di questo membro, vedere ToUInt16(IFormatProvider). For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

Per una descrizione di questo membro, vedere ToUInt32(IFormatProvider). For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

Per una descrizione di questo membro, vedere ToUInt64(IFormatProvider). For a description of this member, see ToUInt64(IFormatProvider).

Applies to

Thread Safety

Tutti i membri di questo tipo sono thread-safe. All members of this type are thread safe. I membri che sembrano modificare lo stato dell'istanza è in realtà restituiscono una nuova istanza inizializzata con il nuovo valore. Members that appear to modify instance state actually return a new instance initialized with the new value. Come con qualsiasi altro tipo, la 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. As with any other type, reading and writing to a shared variable that contains an instance of this type must be protected by a lock to guarantee thread safety.