Boolean Boolean Boolean Boolean Struct

定義

代表布林值 (truefalse)。Represents a Boolean (true or false) value.

public value class Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
[System.Runtime.InteropServices.ComVisible(true)]
[System.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)
繼承
屬性
實作

備註

ABoolean執行個體可以有兩個值: true,或falseA Boolean instance can have either of two values: true, or false.

Boolean結構會提供方法,可支援下列工作:The Boolean structure provides methods that support the following tasks:

下列各節說明這些工作,以及其他使用方式詳細資料:The following sections explain these tasks and other usage details:

格式化的布林值 Formatting Boolean values
布林值的來回轉換 Converting to and from Boolean values
剖析布林值 Parsing Boolean values
比較的布林值 Comparing Boolean values
使用布林值,當做二進位值 Working with Booleans as binary values
執行布林值作業 Performing operations with Boolean values
布林值和 InteropBooleans and Interop

格式化的布林值Formatting Boolean values

字串表示法Boolean為"True"true的值或"False"false值。The string representation of a Boolean is either "True" for a true value or "False" for a false value. 字串表示法Boolean值由所定義的唯讀TrueStringFalseString欄位。The string representation of a Boolean value is defined by the read-only TrueString and FalseString fields.

您使用ToString方法,將布林值轉換成字串。You use the ToString method to convert Boolean values to strings. 布林值的結構包含兩個ToString多載: 無參數ToString()方法和ToString(IFormatProvider)方法,其中包含控制格式設定的參數。The Boolean structure includes two ToString overloads: the parameterless ToString() method and the ToString(IFormatProvider) method, which includes a parameter that controls formatting. 不過,因為會忽略這個參數,兩個多載會產生相同的字串。However, because this parameter is ignored, the two overloads produce identical strings. ToString(IFormatProvider)方法不支援區分文化特性格式。The ToString(IFormatProvider) method does not support culture-sensitive formatting.

下列範例說明格式化與ToString方法。The following example illustrates formatting with the ToString method. 請注意,此範例會使用複合格式功能,因此ToString隱含地呼叫方法。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

因為Boolean結構可以有只有兩個值,就可以輕鬆地新增自訂的格式設定。Because the Boolean structure can have only two values, it is easy to add custom formatting. 簡單自訂格式中的另一個字串常值會取代為"True"和"False",您可以使用任何條件式評估功能,支援您的語言,例如條件式運算子以 C# 或如果運算子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. 下列範例會使用這項技術來格式化Boolean值為"Yes"和"No"而不是"True"和"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

用於更複雜自訂格式化作業,包括 文化特性格式,您可以呼叫String.Format(IFormatProvider, String, Object[])方法,並提供ICustomFormatter實作。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. 下列範例會實作ICustomFormatterIFormatProvider介面,以英文 (美國)、 法文 (法國) 和俄文 (俄羅斯) 文化特性提供區分文化特性的布林值的字串。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': верно

或者,您可以使用資源檔來定義特定文化特性的布林值的字串。Optionally, you can use resource files to define culture-specific Boolean strings.

布林值的來回轉換Converting to and from Boolean values

Boolean結構實作IConvertible介面。The Boolean structure implements the IConvertible interface. 如此一來,您可以使用Convert之間執行轉換的類別Boolean值,以及其他任何基本類型,.NET Framework 中,或者您可以呼叫Boolean結構的明確的實作。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. 不過,之間的轉換Boolean和 下列類型不支援,因此對應的轉換方法會擲回InvalidCastException例外狀況:However, conversions between a Boolean and the following types are not supported, so the corresponding conversion methods throw an InvalidCastException exception:

從整數或浮點數的數字的所有轉換成布林值非零將值轉換成true與零值以falseAll conversions from integral or floating-point numbers to Boolean values convert non-zero values to true and zero values to false. 下列範例將說明這藉由呼叫選取的多載Convert.ToBoolean類別。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

當從浮點值轉換成布林值,轉換方法會執行零的確實比較。When converting from floating-point values to Boolean values, the conversion methods perform an exact comparison with zero. 如果浮點數的值已經失去精確度,可能造成無法預期。If the floating-point value has lost precision, the result can be unexpected. 下列範例中,在其中所示Double其值應為零的變數會轉換成布林值。This is illustrated in the following example, in which a Double variable whose value should be zero is converted to a Boolean value. 如範例所示,結果就是true因為重複加入 0.2 導致失去精確度。As the example shows, the result is true because repeated additions of 0.2 have resulted in a loss of precision.

布林值轉換為數值,轉換的方法時Convert類別轉換true為 1 和false設為 0。When converting from Boolean to numeric values, the conversion methods of the Convert class convert true to 1 and false to 0. 不過,Visual Basic 轉換函式轉換true到任一 255 (轉換成Byte值) 則為-1 (適用於所有其他數值轉換)。However, Visual Basic conversion functions convert true to either 255 (for conversions to Byte values) or -1 (for all other numeric conversions). 下列範例會將轉換true為數值使用Convert方法,並在 Visual Basic 範例中,使用 Visual Basic 語言的自己轉換運算子。The following example converts true to numeric values by using a Convert method, and, in the case of the Visual Basic example, by using the Visual Basic language's own conversion operator.

using System;

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

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

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

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

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

從轉換Boolean字串值,請參閱格式化的布林值一節。For conversions from Boolean to string values, see the Formatting Boolean Values section. 從字串轉換Boolean值,請參閱剖析布林值一節。For conversions from strings to Boolean values, see the Parsing Boolean Values section.

剖析布林值Parsing Boolean values

Boolean結構包含兩個靜態剖析方法,ParseTryParse,可將字串轉換成布林值。The Boolean structure includes two static parsing methods, Parse and TryParse, that convert a string to a Boolean value. 布林值的字串表示的值不區分大小寫對等項目所定義TrueStringFalseString欄位,也就是"True"和"False",分別。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. 換句話說,只有成功剖析的字串是"True"、"False","true"、"false"或某些混合大小寫對等項目。In other words, the only strings that parse successfully are "True", "False", "true", "false", or some mixed-case equivalent. 您無法成功剖析數值字串,例如"0"或"1"。You cannot successfully parse numeric strings such as "0" or "1". 執行字串比較時,不會考慮前置或尾端空格字元。Leading or trailing white-space characters are not considered when performing the string comparison.

下列範例會使用ParseTryParse方法剖析的字串數目。The following example uses the Parse and TryParse methods to parse a number of strings. 請注意,只有不區分大小寫對等項目"True"和"False"可以成功剖析。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'

如果您在 Visual Basic 進行程式設計,您可以使用CBool函式來將數字的字串表示轉換為布林值。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"會轉換成false,而任何非零值的字串表示轉換成true"0" is converted to false, and the string representation of any non-zero value is converted to true. 如果您不在 Visual Basic 進行程式設計,您必須以數字轉換數字的字串,再將它轉換為布林值項目。If you are not programming in Visual Basic, you must convert your numeric string to a number before converting it to a Boolean. 下列範例會說明這藉由將整數的陣列轉換成布林值。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

比較的布林值Comparing Boolean values

布林值都是因為true或是false,不太需要明確呼叫CompareTo方法,即表示執行個體是否大於、 小於、 或等於指定的值。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. 一般而言,若要比較兩個布林值變數,您呼叫Equals方法或使用您語言的等號比較運算子。Typically, to compare two Boolean variables, you call the Equals method or use your language's equality operator.

不過,當您想要比較的常值的布林值的布林值變數truefalse,不需要執行明確的比較,因為評估的布林值的結果是布林值。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. 例如,運算式For example, the expressions

if (booleanValue) {
If booleanValue Then

and

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.

為相等,但第二個而言較為精簡。are equivalent, but the second is more compact. 不過,這兩種技術會提供相當的效能。However, both techniques offer comparable performance.

使用布林值,當做二進位值Working with Booleans as binary values

布林值,會佔用一個位元組的記憶體,如下列 C# 範例所示。A Boolean value occupies one byte of memory, as the following C# example shows. 必須以編譯範例/unsafe切換。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

位元組的低序位位元用來代表它的值。The byte's low-order bit is used to represent its value. 值為 1 代表true; 的值為 0 就表示falseA value of 1 represents true; a value of 0 represents false.

警告

您可以使用System.Collections.Specialized.BitVector32結構使用的布林值的集合。You can use the System.Collections.Specialized.BitVector32 structure to work with sets of Boolean values.

您可以將布林值轉換成其二進位表示法藉由呼叫BitConverter.GetBytes(Boolean)方法。You can convert a Boolean value to its binary representation by calling the BitConverter.GetBytes(Boolean) method. 方法會傳回具有單一元素位元組陣列。The method returns a byte array with a single element. 若要還原的布林值,從其二進位表示法,您可以呼叫BitConverter.ToBoolean(Byte[], Int32)方法。To restore a Boolean value from its binary representation, you can call the BitConverter.ToBoolean(Byte[], Int32) method.

下列範例會呼叫BitConverter.GetBytes方法,將布林值轉換成二進位表示法及顯示的值,並接著呼叫的個別位元BitConverter.ToBoolean從其二進位表示法還原為值的方法。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

執行布林值作業Performing operations with Boolean values

本章節將說明如何布林值會在應用程式。This section illustrates how Boolean values are used in apps. 第一節會討論其用途為旗標。The first section discusses its use as a flag. 第二個說明算術運算的用法。The second illustrates its use for arithmetic operations.

布林值旗標Boolean values as flags

布林值變數是最常用於為旗標,表示某個條件存在。Boolean variables are most commonly used as flags, to signal the presence or absence of some condition. 例如,在String.Compare(String, String, Boolean)方法中,最後一個參數, ignoreCase,表示兩個字串比較是否不區分大小寫的旗標 (ignoreCasetrue) 或區分大小寫 (ignoreCasefalse)。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). 然後在條件陳述式評估的旗標值。The value of the flag can then be evaluated in a conditional statement.

下列範例會使用簡單的主控台應用程式,來說明為旗標的布林值變數使用。The following example uses a simple console app to illustrate the use of Boolean variables as flags. 應用程式會接受命令列參數可讓輸出重新導向至指定的檔案 (/f切換),並可讓輸出傳送至指定的檔案和主控台 (/b切換)。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). 應用程式定義名為旗標isRedirected來指示是否輸出傳送至檔案,以及旗標,名為isBoth表示輸出都應該傳送至主控台。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

布林值和算術運算Booleans and arithmetic operations

布林值,有時可用來指出觸發數學計算的條件存在。A Boolean value is sometimes used to indicate the presence of a condition that triggers a mathematical calculation. 比方說,hasShippingCharge變數可能會做為旗標,指出是否要加入發票量的費用。For example, a hasShippingCharge variable might serve as a flag to indicate whether to add shipping charges to an invoice amount.

因為作業false值沒有任何作用上作業的結果,它不需要將此布林值轉換成在數學運算中使用整數值。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. 相反地,您可以使用條件式邏輯。Instead, you can use conditional logic.

下列範例會計算包含小計、 出貨費用,以及選擇性的服務費用的金額。The following example computes an amount that consists of a subtotal, a shipping charge, and an optional service charge. hasServiceCharge變數可讓您決定是否要套用服務費用。The hasServiceCharge variable determines whether the service charge is applied. 而不是轉換hasServiceCharge數值和乘以服務電量,此範例會使用條件式邏輯加入服務費用金額,如果適用的話。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.

布林值和 interopBooleans and interop

通常直接了當,封送處理至 COM 的基底資料類型時Boolean資料型別為例外狀況。While marshaling base data types to COM is generally straightforward, the Boolean data type is an exception. 您可以套用MarshalAsAttribute封送處理的屬性Boolean任何下列的表示法的型別:You can apply the MarshalAsAttribute attribute to marshal the Boolean type to any of the following representations:

列舉類型Enumeration type Unmanaged 的格式Unmanaged format
UnmanagedType.Bool 4 位元組的整數值,其中任何非零值都代表true並且 0 代表falseA 4-byte integer value, where any nonzero value represents true and 0 represents false. 這是預設的格式為Boolean欄位中的結構和Boolean平台中的參數叫用呼叫。This is the default format of a Boolean field in a structure and of a Boolean parameter in platform invoke calls.
UnmanagedType.U1 1 位元整數值,其中 1 代表true並且 0 代表falseA 1-byte integer value, where the 1 represents true and 0 represents false.
UnmanagedType.VariantBool 2 位元組的整數值,其中-1 代表true並且 0 代表falseA 2-byte integer value, where -1 represents true and 0 represents false. 這是預設的格式為Boolean在 COM interop 呼叫的參數。This is the default format of a Boolean parameter in COM interop calls.

欄位

FalseString FalseString FalseString FalseString

將布林值 false 表示為字串。Represents the Boolean value false as a string. 此欄位為唯讀。This field is read-only.

TrueString TrueString TrueString TrueString

將布林值 true 表示為字串。Represents the Boolean value true as a string. 此欄位為唯讀。This field is read-only.

方法

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

比較這個執行個體與指定的 Boolean 物件,並傳回整數,這個整數表示兩者彼此的關聯性。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)

將這個執行個體與指定的物件相比較,並傳回整數,這個整數表示兩者彼此的關聯性 (Relationship)。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)

傳回表示這個執行個體是否等於指定 Boolean 物件的值。Returns a value indicating whether this instance is equal to a specified Boolean object.

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

傳回值,指出這個執行個體 (Instance) 是否和指定的物件相等。Returns a value indicating whether this instance is equal to a specified object.

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

傳回這個執行個體的雜湊碼。Returns the hash code for this instance.

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

傳回 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)

將指定之邏輯值的字串表示,轉換為相等的 BooleanConverts the specified string representation of a logical value to its Boolean equivalent.

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

將這個執行個體的值轉換為它的對等字串表示 ("True" 或 "False")。Converts the value of this instance to its equivalent string representation (either "True" or "False").

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

將這個執行個體的值轉換為它的對等字串表示 ("True" 或 "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)

嘗試將指定之邏輯值的字串表示轉換成對等的 BooleanTries to convert the specified string representation of a logical value to its Boolean equivalent. 傳回值會指出轉換成功或失敗。A return value indicates whether the conversion succeeded or failed.

明確介面實作

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)

如需這個成員的說明,請參閱 ToBoolean(IFormatProvider)For a description of this member, see ToBoolean(IFormatProvider).

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

如需這個成員的說明,請參閱 ToByte(IFormatProvider)For a description of this member, see ToByte(IFormatProvider).

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

不支援這個轉換。This conversion is not supported. 嘗試使用這個方法會擲回 InvalidCastExceptionAttempting to use this method throws an InvalidCastException.

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

不支援這個轉換。This conversion is not supported. 嘗試使用這個方法會擲回 InvalidCastExceptionAttempting to use this method throws an InvalidCastException.

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

如需這個成員的說明,請參閱 ToDecimal(IFormatProvider)For a description of this member, see ToDecimal(IFormatProvider).

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

如需這個成員的說明,請參閱 ToDouble(IFormatProvider)For a description of this member, see ToDouble(IFormatProvider).

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

如需這個成員的說明,請參閱 ToInt16(IFormatProvider)For a description of this member, see ToInt16(IFormatProvider).

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

如需這個成員的說明,請參閱 ToInt32(IFormatProvider)For a description of this member, see ToInt32(IFormatProvider).

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

如需這個成員的說明,請參閱 ToInt64(IFormatProvider)For a description of this member, see ToInt64(IFormatProvider).

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

如需這個成員的說明,請參閱 ToSByte(IFormatProvider)For a description of this member, see ToSByte(IFormatProvider).

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

如需這個成員的說明,請參閱 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)

如需這個成員的說明,請參閱 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)

如需這個成員的說明,請參閱 ToUInt16(IFormatProvider)For a description of this member, see ToUInt16(IFormatProvider).

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

如需這個成員的說明,請參閱 ToUInt32(IFormatProvider)For a description of this member, see ToUInt32(IFormatProvider).

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

如需這個成員的說明,請參閱 ToUInt64(IFormatProvider)For a description of this member, see ToUInt64(IFormatProvider).

適用於

執行緒安全性

此型別的所有成員都是安全執行緒。All members of this type are thread safe. 若要修改執行個體狀態會顯示的成員實際上會傳回新的值進行初始化的新執行個體。Members that appear to modify instance state actually return a new instance initialized with the new value. 為與任何其他型別,讀取和寫入共用的變數,其中包含這個型別的執行個體必須受到鎖定,以確保執行緒安全性。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.