Boolean 結構

定義

代表布林值 (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)
繼承
Boolean
屬性
實作

備註

Boolean 實例可以有兩個值的其中一個: truefalseA 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 中的If 運算子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 介面,以提供英文(美國)、法文(法國)和俄文(俄羅斯)文化特性的區分文化特性(culture)布林字串。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 類別,在 .NET 中的 Boolean 值和任何其他基本型別之間執行轉換,也可以呼叫 Boolean 結構的明確實值。As a result, you can use the Convert class to perform conversions between a Boolean value and any other primitive type in .NET, 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). 下列範例會使用 Convert 方法,將 true 轉換為數值,而在 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

因為布林值是 truefalse,所以沒有明確呼叫 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 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. 這是 COM Interop 呼叫中 Boolean 參數的預設格式。This is the default format of a Boolean parameter in COM interop calls.

欄位

FalseString

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

TrueString

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

方法

CompareTo(Boolean)

比較這個執行個體與指定的 Boolean 物件,並傳回整數,這個整數表示兩者彼此的關聯性。Compares this instance to a specified Boolean object and returns an integer that indicates their relationship to one another.

CompareTo(Object)

將這個執行個體與指定的物件相比較,並傳回整數,這個整數表示兩者彼此的關聯性 (Relationship)。Compares this instance to a specified object and returns an integer that indicates their relationship to one another.

Equals(Boolean)

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

Equals(Object)

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

GetHashCode()

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

GetTypeCode()

傳回 Boolean 實值類型的類型程式碼。Returns the type code for the Boolean value type.

Parse(ReadOnlySpan<Char>)

將代表邏輯值的指定範圍轉換為其對等 BooleanConverts the specified span representation of a logical value to its Boolean equivalent.

Parse(String)

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

ToString()

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

ToString(IFormatProvider)

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

TryFormat(Span<Char>, Int32)

嘗試將目前布林執行個體的值格式化為所提供字元範圍。Tries to format the value of the current boolean instance into the provided span of characters.

TryParse(ReadOnlySpan<Char>, Boolean)

嘗試將代表邏輯值的指定範圍轉換為對等 BooleanTries to convert the specified span representation of a logical value to its Boolean equivalent.

TryParse(String, Boolean)

嘗試將指定之邏輯值的字串表示轉換成對等的 BooleanTries to convert the specified string representation of a logical value to its Boolean equivalent.

明確介面實作

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

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

IConvertible.ToByte(IFormatProvider)

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

IConvertible.ToChar(IFormatProvider)

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

IConvertible.ToDateTime(IFormatProvider)

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

IConvertible.ToDecimal(IFormatProvider)

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

IConvertible.ToDouble(IFormatProvider)

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

IConvertible.ToInt16(IFormatProvider)

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

IConvertible.ToInt32(IFormatProvider)

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

IConvertible.ToInt64(IFormatProvider)

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

IConvertible.ToSByte(IFormatProvider)

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

IConvertible.ToSingle(IFormatProvider)

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

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

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

IConvertible.ToUInt16(IFormatProvider)

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

IConvertible.ToUInt32(IFormatProvider)

如需這個成員的說明,請參閱 ToUInt32(IFormatProvider)For a description of this member, see ToUInt32(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.