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
布尔值和互操作Booleans 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#的条件运算符或中的If 运算符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 类在 .NET Framework 中 Boolean 值和任何其他基元类型之间执行转换,或者可以调用 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.

从 Boolean 转换为数值时,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. 布尔值的字符串表示形式由 "TrueString" 和 "FalseString" 字段的值的不区分大小写的等效项定义,分别为 "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

布尔值占用1个字节的内存,如下面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) 方法中,final 参数 ignoreCase是一个标志,它指示两个字符串的比较是否不区分大小写(ignoreCase true)或区分大小写(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.

布尔值和互操作Booleans 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 互操作调用中 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)

将此实例与指定对象进行比较,并返回一个指示二者关系的整数。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)

尝试将逻辑值的指定字符串表示形式转换为其等效的 Boolean 值。Tries 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.