Boolean Struktur

Definition

Stellt einen booleschen Wert dar (true oder 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)
Vererbung
Boolean
Attribute
Implementiert

Hinweise

Eine Boolean -Instanz kann einen von zwei Werten haben: true oder false .

Die Boolean -Struktur stellt Methoden zur Verfügung, die die folgenden Aufgaben unterstützen:

  • Konvertieren boolescher Werte in Zeichenfolgen: ToString

  • Analyse von Zeichenfolgen, um sie in boolesche Werte zu konvertieren: Parse und TryParse

  • Vergleich von Werten: CompareTo und Equals

In den folgenden Abschnitten werden diese Aufgaben und andere Nutzungsdetails erläutert:

Formatieren von booleschen Werten

Die Zeichenfolgendarstellung eines Boolean ist entweder "True" für einen true Wert oder "False" für einen false Wert. Die Zeichenfolgendarstellung eines Boolean Werts wird durch die schreibgeschützten Felder TrueString und FalseString definiert.

Sie verwenden die ToString -Methode, um boolesche Werte in Zeichenfolgen zu konvertieren. Die boolesche Struktur enthält zwei Überladungen: die parameterlose Methode und die -Methode, die einen Parameter ToString ToString() ToString(IFormatProvider) enthält, der die Formatierung steuert. Da dieser Parameter jedoch ignoriert wird, erzeugen die beiden Überladungen identische Zeichenfolgen. Die ToString(IFormatProvider) -Methode unterstützt keine kulturempfindliche Formatierung.

Das folgende Beispiel veranschaulicht die Formatierung mit der ToString -Methode. Beachten Sie, dass im Beispiel die Funktion für die kombinierte Formatierung verwendet wird, sodass die ToString -Methode implizit aufgerufen wird.

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

Da die Boolean Struktur nur zwei Werte enthalten kann, ist es einfach, benutzerdefinierte Formatierung hinzuzufügen. Für einfache benutzerdefinierte Formatierungen, bei denen andere Zeichenfolgenliterale durch "True" und "False" ersetzt werden, können Sie jedes von Ihrer Sprache unterstützte Feature für die bedingte Auswertung verwenden, z. B. den bedingten Operator in C# oder den If-Operator in Visual Basic. Im folgenden Beispiel wird diese Technik verwendet, um Werte als Boolean "Ja" und "Nein" statt als "True" und "False" zu formatieren.

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

Für komplexere benutzerdefinierte Formatierungsvorgänge, einschließlich kultursensibler Formatierung, können Sie die -Methode aufrufen String.Format(IFormatProvider, String, Object[]) und eine Implementierung ICustomFormatter bereitstellen. Im folgenden Beispiel werden die Schnittstellen und implementiert, um kulturempfindliche boolesche Zeichenfolgen für die Kulturen Englisch (USA), Französisch (Frankreich) und Russisch ICustomFormatter IFormatProvider (Spanien) zu bieten.

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

Optional können Sie Ressourcendateien verwenden, um kulturspezifische boolesche Zeichenfolgen zu definieren.

Konvertieren in und aus booleschen Werten

Die Boolean -Struktur implementiert die IConvertible -Schnittstelle. Daher können Sie die -Klasse verwenden, um Konvertierungen zwischen einem Wert und einem beliebigen anderen primitiven Typ Convert in .NET durchzuführen, oder Sie können die expliziten Implementierungen der Boolean Boolean Struktur aufrufen. Konvertierungen zwischen einem und den folgenden Typen werden jedoch nicht unterstützt, sodass die entsprechenden Boolean Konvertierungsmethoden eine Ausnahme InvalidCastException auslösen:

Alle Konvertierungen von Ganzzahl- oder Gleitkommazahlen in boolesche Werte konvertieren Werte, die nicht null sind, in und true Nullwerte in false . Im folgenden Beispiel wird dies durch Aufrufen ausgewählter Überladungen der -Klasse Convert.ToBoolean veranschaulicht.

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

Beim Konvertieren von booleschen Werten in numerische Werte werden die Konvertierungsmethoden der -Klasse Convert in true 1 und false 0 konvertiert. Allerdings Visual Basic Konvertierungsfunktionen entweder in 255 (für Konvertierungen in Werte) oder -1 (für alle anderen numerischen true Byte Konvertierungen) konvertieren. Im folgenden Beispiel wird mithilfe einer -Methode in numerische Werte konvertiert, und im Fall des Visual Basic-Beispiels mithilfe des eigenen Konvertierungsoperator der true Convert Visual Basic-Sprache.

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)

Informationen zu Konvertierungen von Boolean in Zeichenfolgenwerte finden Sie im Abschnitt Formatieren boolescher Werte. Informationen zu Konvertierungen von Zeichenfolgen in Werte finden Sie im Abschnitt Boolean Analyse boolescher Werte.

Analysieren boolescher Werte

Die Boolean -Struktur enthält zwei statische Analysemethoden, Parse und , die eine TryParse Zeichenfolge in einen booleschen Wert konvertieren. Die angegebene Zeichenfolgendarstellung eines booleschen Werts wird durch die Groß-/Kleinschreibung Entsprechungen der Werte von definiert die TrueString und FalseString Felder, die "True" und "Falsch", bzw. Anders ausgedrückt: Die einzigen Zeichenfolgen, die erfolgreich analysiert werden, sind "True", "False", "true", "false" oder eine Entsprechung in gemischter Zeichenfolge. Numerische Zeichenfolgen wie "0" oder "1" können nicht erfolgreich analysiert werden. Führende oder nachrangende Leerzeichen werden beim Durchführen des Zeichenfolgenvergleichs nicht berücksichtigt.

Im folgenden Beispiel werden die Methoden Parse und TryParse verwendet, um eine Reihe von Zeichenfolgen zu analysieren. Beachten Sie, dass nur die Entsprechungen "True" und "False" ohne Unterscheidung nach Groß-/Kleinschreibung erfolgreich analysiert werden können.

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'

Wenn Sie in einem Visual Basic, können Sie die -Funktion verwenden, um die Zeichenfolgendarstellung einer Zahl in einen CBool booleschen Wert zu konvertieren. "0" wird in konvertiert, und die Zeichenfolgendarstellung eines beliebigen Werts, der nicht 0 false (null) ist, wird in true konvertiert. Wenn Sie nicht in der Visual Basic, müssen Sie die numerische Zeichenfolge in eine Zahl konvertieren, bevor Sie sie in einen booleschen Wert konvertieren. Im folgenden Beispiel wird dies veranschaulicht, indem ein Array von ganzen Zahlen in boolesche Werte konvertiert wird.

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

Vergleichen von booleschen Werten

Da boolesche Werte entweder oder sind, gibt es wenig Grund zum expliziten Aufrufen der -Methode, die angibt, ob eine Instanz größer als, kleiner oder gleich einem angegebenen true false Wert CompareTo ist. In der Regel rufen Sie zum Vergleichen von zwei booleschen Variablen die -Methode auf oder verwenden den Equals Gleichheitsoperator Ihrer Sprache.

Wenn Sie jedoch eine boolesche Variable mit dem literalen booleschen Wert oder vergleichen möchten, ist es nicht erforderlich, einen expliziten Vergleich zu erstellen, da das Ergebnis der Auswertung eines booleschen Werts dieser boolesche Wert true false ist. Beispielsweise die Ausdrücke

if (booleanValue == true) {
If booleanValue = True Then

und

if (booleanValue) {
If booleanValue Then

sind gleichwertig, aber die zweite ist kompakter. Beide Techniken bieten jedoch eine vergleichbare Leistung.

Arbeiten mit booleanen Werten als Binärwerte

Ein boolescher Wert belegt ein Byte Arbeitsspeicher, wie im folgenden C#-Beispiel gezeigt. Das Beispiel muss mit dem Schalter kompiliert /unsafe werden.

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

Das niedrige Bit des Byte wird verwendet, um seinen Wert zu darstellen. Der Wert 1 stellt true dar. Der Wert 0 stellt false dar.

Tipp

Sie können die System.Collections.Specialized.BitVector32 -Struktur verwenden, um mit booleschen Werten zu arbeiten.

Sie können einen booleschen Wert in seine binäre Darstellung konvertieren, indem Sie die -Methode BitConverter.GetBytes(Boolean) aufrufen. Die -Methode gibt ein Bytearray mit einem einzelnen Element zurück. Um einen booleschen Wert aus seiner binären Darstellung wiederherzustellen, können Sie die -Methode BitConverter.ToBoolean(Byte[], Int32) aufrufen.

Das folgende Beispiel ruft die -Methode auf, um einen booleschen Wert in seine binäre Darstellung zu konvertieren, zeigt die einzelnen Bits des Werts an und ruft dann die -Methode auf, um den Wert aus seiner binären Darstellung BitConverter.GetBytes BitConverter.ToBoolean wiederherzustellen.

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

Ausführen von Vorgängen mit booleschen Werten

In diesem Abschnitt wird veranschaulicht, wie boolesche Werte in Apps verwendet werden. Im ersten Abschnitt wird die Verwendung als Flag erläutert. Im zweiten Beispiel wird die Verwendung für arithmetische Operationen veranschaulicht.

Boolesche Werte als Flags

Boolesche Variablen werden am häufigsten als Flags verwendet, um das Vorhandensein oder Fehlen einer Bedingung zu signalisieren. Beispielsweise ist der letzte Parameter in der -Methode ein Flag, das angibt, ob beim Vergleich zweier Zeichenfolgen die Groß-/Kleinschreibung nicht beachtet wird ( ist ), oder die String.Compare(String, String, Boolean) ignoreCase ignoreCase true Groß-/Kleinschreibung beachtet wird ( ist ignoreCase false ). Der Wert des Flags kann dann in einer bedingungsbedingten Anweisung ausgewertet werden.

Im folgenden Beispiel wird eine einfache Konsolen-App verwendet, um die Verwendung boolescher Variablen als Flags zu veranschaulichen. Die App akzeptiert Befehlszeilenparameter, die es ermöglichen, die Ausgabe an eine angegebene Datei (den Schalter) umzuleiten und die Ausgabe sowohl an eine angegebene Datei als auch an die Konsole (den Schalter) zu gesendet /f /b werden. Die App definiert ein Flag namens , um anzugeben, ob die Ausgabe an eine Datei gesendet werden soll, und ein Flag namens , um anzugeben, dass die Ausgabe an die isRedirected isBoth Konsole gesendet werden soll.

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

Boolesch und arithmetische Operationen

Ein boolescher Wert wird manchmal verwendet, um das Vorhandensein einer Bedingung anzugeben, die eine mathematische Berechnung auslöst. Beispielsweise kann eine Variable als Flag dienen, um anzugeben, ob einem Rechnungsbetrag hasShippingCharge Versandgebühren hinzugefügt werden sollen.

Da ein Vorgang mit einem -Wert keine Auswirkung auf das Ergebnis eines Vorgangs hat, ist es nicht erforderlich, den booleschen Wert in einen ganzzahlischen Wert zu konvertieren, der in der mathematischen Operation false verwendet werden soll. Stattdessen können Sie bedingte Logik verwenden.

Im folgenden Beispiel wird ein Betrag berechnet, der aus einer Zwischensumme, einer Versandgebühr und einer optionalen Dienstgebühr besteht. Die hasServiceCharge Variable bestimmt, ob die Dienstgebühr angewendet wird. Anstatt in einen numerischen Wert zu konvertieren und ihn mit dem Betrag der Dienstgebühr zu multiplizieren, verwendet das Beispiel bedingte Logik, um ggf. den Betrag der Dienstgebühr hasServiceCharge hinzuzufügen.

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.

Booleaner Und-Interop

Obwohl das Marshallen von Basisdatentypen an COM im Allgemeinen unkompliziert ist, ist Boolean der Datentyp eine Ausnahme. Sie können das MarshalAsAttribute -Attribut anwenden, um den Typ Boolean in eine der folgenden Darstellungen zu marshallen:

Enumerationstyp Nicht verwaltetes Format
UnmanagedType.Bool Ein 4-Byte-Ganzzahlwert, bei dem jeder Wert ungleich 0 und true 0 false darstellt. Dies ist das Standardformat eines Boolean Felds in einer Struktur und eines Parameters Boolean in Plattformaufrufen.
UnmanagedType.U1 Ein 1-Byte-Ganzzahlwert, bei dem 1 und true 0 false darstellt.
UnmanagedType.VariantBool Ein 2-Byte-Ganzzahlwert, wobei -1 und true 0 false darstellt. Dies ist das Standardformat eines Parameters Boolean in COM-Interopaufrufen.

Felder

FalseString

Stellt den booleschen Wert false als eine Zeichenfolge dar. Dieses Feld ist schreibgeschützt.

TrueString

Stellt den booleschen Wert true als eine Zeichenfolge dar. Dieses Feld ist schreibgeschützt.

Methoden

CompareTo(Boolean)

Vergleicht diese Instanz mit einem angegebenen Boolean-Objekt und gibt eine ganze Zahl zurück, die ihre Beziehung untereinander angibt.

CompareTo(Object)

Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die ihre Beziehung untereinander angibt.

Equals(Boolean)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Boolean-Objekt ist.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.

GetHashCode()

Gibt den Hashcode für diese Instanz zurück.

GetTypeCode()

Gibt den Typcode für den Boolean-Werttyp zurück.

Parse(ReadOnlySpan<Char>)

Konvertiert die angegebene Spannendarstellung eines logischen Werts in sein Boolean-Äquivalent.

Parse(String)

Konvertiert die angegebene Zeichenfolgendarstellung eines logischen Werts in seine Boolean-Entsprechung.

ToString()

Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung (entweder „True“ oder „False“).

ToString(IFormatProvider)

Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung (entweder „True“ oder „False“).

TryFormat(Span<Char>, Int32)

Versucht, den Wert der aktuellen booleschen Instanz in die angegebene Zeichenspanne zu formatieren.

TryParse(ReadOnlySpan<Char>, Boolean)

Versucht, die angegebene Spannendarstellung eines logischen Werts in das Boolean-Äquivalent zu konvertieren.

TryParse(String, Boolean)

Versucht, die angegebene Zeichenfolgendarstellung eines logischen Werts in die Boolean-Entsprechung zu konvertieren.

Explizite Schnittstellenimplementierungen

IComparable.CompareTo(Object)

Vergleicht die aktuelle Instanz mit einem anderen Objekt vom selben Typ und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz in der Sortierreihenfolge vor oder nach dem anderen Objekt oder an derselben Position auftritt.

IConvertible.GetTypeCode()

Gibt den TypeCode für diese Instanz zurück.

IConvertible.ToBoolean(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToDateTime(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToDecimal(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider)

Hiermit wird der Wert dieser Instanz unter Verwendung der angegebenen kulturabhängigen Formatierungsinformationen in eine entsprechende Zeichenfolge konvertiert.

IConvertible.ToType(Type, IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider).

Gilt für:

Threadsicherheit

Alle Member dieses Typs sind threadsicher. Member, die den Instanzzustand zu ändern scheinen, geben tatsächlich eine neue Instanz zurück, die mit dem neuen Wert initialisiert wurde. Wie bei jedem anderen Typ muss das Lesen und Schreiben in eine freigegebene Variable, die eine Instanz dieses Typs enthält, durch eine Sperre geschützt werden, um die Threadsicherheit zu gewährleisten.