Boolean 结构

参考

定义

命名空间:: System

程序集:: System.Runtime.dll

程序集:: netstandard.dll

程序集:: mscorlib.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

表示一个布尔（true 或 false）值。

public value class bool : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>

public value class bool : IComparable, IConvertible

public value class bool : IComparable, IComparable<bool>, IEquatable<bool>

public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>

[System.Serializable]
public struct Boolean : IComparable, IConvertible

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>

public struct Boolean : IComparable, IComparable<bool>, IEquatable<bool>

type bool = struct
    interface IConvertible

[<System.Serializable>]
type bool = struct
    interface IConvertible

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type bool = struct
    interface IConvertible

type bool = struct

Public Structure Boolean
Implements IComparable, IComparable(Of Boolean), IConvertible, IEquatable(Of Boolean)

Public Structure Boolean
Implements IComparable, IConvertible

Public Structure Boolean
Implements IComparable, IComparable(Of Boolean), IEquatable(Of Boolean)

继承: Object

ValueType
Boolean

属性: SerializableAttribute ComVisibleAttribute

实现: IComparable IComparable<Boolean> IConvertible IEquatable<Boolean>

注解

Boolean实例可以有两个值之一： true 或 false 。

Boolean结构提供支持以下任务的方法：

将布尔值转换为字符串： ToString
分析字符串以将其转换为布尔值： Parse 和 TryParse
比较值： CompareTo 和 Equals

以下部分介绍了这些任务和其他使用情况详细信息：

设置布尔值格式
与布尔值相互转换
分析布尔值
比较布尔值
使用布尔值作为二进制值
用布尔值执行操作
布尔值和互操作

设置布尔值格式

的字符串表示形式 Boolean 对于值为 "True"， true 对于值为 "False" false 。值的字符串表示形式 Boolean 由只读 TrueString 和 FalseString 字段定义。

使用方法将 ToString 布尔值转换为字符串。布尔结构包括两个 ToString 重载：无参数 ToString() 方法和 ToString(IFormatProvider) 方法，包括用于控制格式设置的参数。但是，因为此参数被忽略，所以这两个重载生成相同的字符串。此 ToString(IFormatProvider) 方法不支持区分区域性的格式设置。

下面的示例演示如何用方法进行格式设置 ToString 。请注意，该示例使用复合格式设置功能，因此该 ToString 方法是隐式调用的。

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 结构只能有两个值，因此可轻松添加自定义格式。对于其他字符串文本替换为 "True" 和 "False" 的简单自定义格式设置，可以使用您的语言支持的任何条件求值功能，如 c # 中的条件运算符或 Visual Basic 中的If 运算符。下面的示例使用此方法将 Boolean 值设置为 "Yes" 和 "No" 而不是 "True" 和 "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 实现。下面的示例实现 ICustomFormatter 和 IFormatProvider 接口，为英语 (美国) 、法语 (法国) 和俄语 (俄罗斯) 区域性提供区分区域性的布尔字符串。

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': верно

或者，您可以使用资源文件来定义特定于区域性的布尔字符串。

与布尔值相互转换

Boolean结构实现 IConvertible 接口。因此，你可以使用 Convert 类 Boolean 在 .net 中的值与任何其他基元类型之间执行转换，或者可以调用 Boolean 结构的显式实现。但是， Boolean 不支持在和下面的类型之间进行转换，因此相应的转换方法将引发 InvalidCastException 异常：

和 Boolean Char (和方法之间的转换 Convert.ToBoolean(Char) Convert.ToChar(Boolean))
和 Boolean DateTime (和方法之间的转换 Convert.ToBoolean(DateTime) Convert.ToDateTime(Boolean))

从整数或浮点数到布尔值的所有转换都将非零值转换为 true ，并将零值转换为 false 。下面的示例通过调用类的选定重载阐释了这一点 Convert.ToBoolean 。

using System;

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

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

当从 Boolean 转换为数值时，类的转换方法 Convert 将转换 true 为1和 false 0。但是，Visual Basic 转换函数转换 true 为 255 (，以便转换为 Byte 值) 或-1 (对于所有其他数值转换) 。下面的示例使用 true 方法转换为数值 Convert ，在 Visual Basic 示例中，通过使用 Visual Basic 语言自身的转换运算符来转换为数值。

using System;

public class Example
{
   public static void Main()
   {
      bool flag = true;

      byte byteValue;
      byteValue = Convert.ToByte(flag);
      Console.WriteLine("{0} -> {1}", flag, byteValue);

      sbyte sbyteValue;
      sbyteValue = Convert.ToSByte(flag);
      Console.WriteLine("{0} -> {1}", flag, sbyteValue);

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

      int intValue;
      intValue = Convert.ToInt32(flag);
      Console.WriteLine("{0} -> {1}", flag, intValue);
   }
}
// The example displays the following output:
//       True -> 1
//       True -> 1
//       True -> 1
//       True -> 1

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若要从转换为字符串值，请参阅设置布尔值格式部分。若要将字符串转换为 Boolean 值，请参阅分析布尔值部分。

分析布尔值

该 Boolean 结构包括两个静态分析方法， Parse 以及 TryParse 用于将字符串转换为布尔值的。布尔值的字符串表示形式由 TrueString 和字段的值 FalseString （分别为 "True" 和 "False"）的值的不区分大小写的等效项定义。换句话说，分析成功的唯一字符串为 "True"、"False"、"true"、"false" 或一些等效大小写。无法成功分析数值字符串，如 "0" 或 "1"。执行字符串比较时不考虑前导或尾随空白字符。

下面的示例使用 Parse 和 TryParse 方法来分析多个字符串。请注意，只能成功分析不区分大小写的 "True" 和 "False" 的等效项。

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 函数将数字的字符串表示形式转换为布尔值。 "0" 转换为 false ，任何非零值的字符串表示形式均转换为 true 。如果不是在 Visual Basic 进行编程，则必须先将数值字符串转换为数字，然后再将其转换为布尔值。下面的示例通过将整数数组转换为布尔值来说明这一点。

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

比较布尔值

由于布尔值为 true 或 false ，因此无需显式调用 CompareTo 方法，这将指示实例是大于、小于还是等于指定值。通常，若要比较两个布尔变量，请调用 Equals 方法或使用语言的相等运算符。

但是，当您想要将布尔变量与文本布尔值进行比较时， true false 不需要进行显式比较，因为对布尔值进行求值的结果是布尔值。例如，表达式

if (booleanValue == true) {

If booleanValue = True Then

和

if (booleanValue) {

If booleanValue Then

等效，但第二个更为紧凑。但是，这两种方法提供的性能相当。

使用布尔值作为二进制值

布尔值占用1个字节的内存，如以下 c # 示例所示。必须用开关编译该示例 /unsafe 。

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

字节的低位位用于表示其值。值为1表示 true ; 值为0表示 false 。

提示

您可以使用 System.Collections.Specialized.BitVector32 结构来处理布尔值集。

可以通过调用方法将布尔值转换为其二进制表示形式 BitConverter.GetBytes(Boolean) 。方法返回包含单个元素的字节数组。若要从布尔值的二进制表示形式还原布尔值，可以调用 BitConverter.ToBoolean(Byte[], Int32) 方法。

下面的示例调用 BitConverter.GetBytes 方法将布尔值转换为其二进制表示形式，并显示值的各个位，然后调用 BitConverter.ToBoolean 方法以从其二进制表示形式还原值。

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

用布尔值执行操作

本部分说明如何在应用中使用布尔值。第一部分讨论其用作标志。第二个示例演示了如何使用算术运算。

布尔值作为标志

布尔变量最常用作标志，用于指示存在还是缺少某个条件。例如，在方法中 String.Compare(String, String, Boolean) ，最后 ignoreCase 一个参数是一个标志，它指示两个字符串的比较是否不区分大小写 (ignoreCase true) 还是) 区分大小写的 (ignoreCase false 。然后，可以在条件语句中计算标志的值。

下面的示例使用一个简单的控制台应用程序，说明如何使用布尔变量作为标志。应用接受命令行参数，这些参数可使输出重定向到指定的文件 (/f 交换机) ，并使输出可同时发送到指定的文件和控制台 (/b 交换机) 。应用程序定义了一个名 isRedirected 为的标志，用于指示是否将输出发送到文件，以及一个名为的标志， isBoth 用于指示应将输出发送到控制台。

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

布尔值和算术运算

布尔值有时用于指示触发数学计算的条件是否存在。例如， hasShippingCharge 变量可用作标志，用于指示是否将装运费用添加到发票金额。

由于具有值的操作不 false 会影响操作的结果，因此无需将布尔值转换为整数值即可在数学运算中使用。相反，您可以使用条件逻辑。

下面的示例计算一个由小计、运费和可选的服务费用组成的量。 hasServiceCharge变量确定是否应用服务费用。 hasServiceCharge此示例使用条件逻辑来添加服务费用量（如果适用），而不是转换为数字值并将其乘以服务费用量。

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.

布尔值和互操作

在将基本数据类型封送到 COM 时，通常是 Boolean 一种异常。您可以应用 MarshalAsAttribute 特性将类型封送 Boolean 到以下任何表示形式：

枚举类型	非托管格式
UnmanagedType.Bool	一个4字节的整数值，其中任何非零值都表示 `true` ，0表示 `false` 。这是 Boolean 平台调用中的结构和参数的默认格式 Boolean 。
UnmanagedType.U1	1个字节的整数值，其中1表示 `true` ，0表示 `false` 。
UnmanagedType.VariantBool	2字节整数值，其中-1 表示 `true` ，0表示 `false` 。这是 COM 互操作调用 Boolean 中参数的默认格式。

字段

FalseString	将布尔值 `false` 表示为一个字符串。此字段为只读。
TrueString	将布尔值 `true` 表示为一个字符串。此字段为只读。

方法

CompareTo(Boolean)	将此实例与指定的 Boolean 对象进行比较，并返回一个指示二者关系的整数。
CompareTo(Object)	将此实例与指定对象进行比较，并返回一个指示二者关系的整数。
Equals(Boolean)	返回一个值，该值指示此实例是否与指定的 Boolean 相等。
Equals(Object)	返回一个值，该值指示此实例是否等于指定的对象。
GetHashCode()	返回此实例的哈希代码。
GetTypeCode()	返回 Boolean 值类型的类型代码。
Parse(ReadOnlySpan<Char>)	将逻辑值的指定范围表示形式转换为它的等效 Boolean。
Parse(String)	将逻辑值的指定字符串表示形式转换为其等效的 Boolean。
ToString()	将此实例的值转换为其等效字符串表示形式（“True”或“False”）。
ToString(IFormatProvider)	将此实例的值转换为其等效字符串表示形式（“True”或“False”）。
TryFormat(Span<Char>, Int32)	尝试将当前布尔实例的值的格式设置为提供的字符范围。
TryParse(ReadOnlySpan<Char>, Boolean)	尝试将逻辑值的指定范围表示形式转换为它的等效 Boolean。
TryParse(String, Boolean)	尝试将逻辑值的指定字符串表示形式转换为其等效的 Boolean 值。

显式接口实现

IComparable.CompareTo(Object)	将当前实例与同一类型的另一个对象进行比较，并返回一个整数，该整数指示当前实例在排序顺序中的位置是位于另一个对象之前、之后还是与其位置相同。
IConvertible.GetTypeCode()	返回此实例的 TypeCode。
IConvertible.ToBoolean(IFormatProvider)	有关此成员的说明，请参见 ToBoolean(IFormatProvider)。
IConvertible.ToByte(IFormatProvider)	有关此成员的说明，请参见 ToByte(IFormatProvider)。
IConvertible.ToChar(IFormatProvider)	不支持此转换。尝试使用此方法将引发 InvalidCastException。
IConvertible.ToDateTime(IFormatProvider)	不支持此转换。尝试使用此方法将引发 InvalidCastException。
IConvertible.ToDecimal(IFormatProvider)	有关此成员的说明，请参见 ToDecimal(IFormatProvider)。
IConvertible.ToDouble(IFormatProvider)	有关此成员的说明，请参见 ToDouble(IFormatProvider)。
IConvertible.ToInt16(IFormatProvider)	有关此成员的说明，请参见 ToInt16(IFormatProvider)。
IConvertible.ToInt32(IFormatProvider)	有关此成员的说明，请参见 ToInt32(IFormatProvider)。
IConvertible.ToInt64(IFormatProvider)	有关此成员的说明，请参见 ToInt64(IFormatProvider)。
IConvertible.ToSByte(IFormatProvider)	有关此成员的说明，请参见 ToSByte(IFormatProvider)。
IConvertible.ToSingle(IFormatProvider)	有关此成员的说明，请参见 ToSingle(IFormatProvider)。
IConvertible.ToString(IFormatProvider)	使用指定的区域性特定格式设置信息将此实例的值转换为等效的字符串。
IConvertible.ToType(Type, IFormatProvider)	有关此成员的说明，请参见 ToType(Type, IFormatProvider)。
IConvertible.ToUInt16(IFormatProvider)	有关此成员的说明，请参见 ToUInt16(IFormatProvider)。
IConvertible.ToUInt32(IFormatProvider)	有关此成员的说明，请参见 ToUInt32(IFormatProvider)。
IConvertible.ToUInt64(IFormatProvider)	有关此成员的说明，请参见 ToUInt64(IFormatProvider)。

适用于

线程安全性

此类型的所有成员都是线程安全的。似乎要修改实例状态的成员实际上返回用新值初始化的新实例。与任何其他类型一样，读取和写入包含此类型的实例的共享变量必须受锁保护，以确保线程安全。