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 aufweisen: true oder false .

Die Boolean -Struktur stellt Methoden bereit, die die folgenden Aufgaben unterstützen:

  • Konvertieren von booleschen Werten in Zeichenfolgen: ToString

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

  • Vergleichen 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 TrueString Felder und FalseString definiert.

Sie verwenden die ToString -Methode, um boolesche Werte in Zeichenfolgen zu konvertieren. Die boolesche Struktur enthält zwei ToString Überladungen: die parameterlose ToString() Methode und die ToString(IFormatProvider) -Methode, die einen Parameter 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 kulturabhängige Formatierung.

Im folgenden Beispiel wird die Formatierung mit der ToString -Methode veranschaulicht. Beachten Sie, dass im Beispiel die Funktion für die zusammengesetzte 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 Formatierungen hinzuzufügen. Für eine einfache benutzerdefinierte Formatierung, bei der 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 Boolean Werte als "Ja" und "Nein" anstatt 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 kulturabhängiger Formatierung, können Sie die -Methode aufrufen String.Format(IFormatProvider, String, Object[]) und eine ICustomFormatter -Implementierung bereitstellen. Im folgenden Beispiel werden die ICustomFormatter Schnittstellen und IFormatProvider implementiert, um kulturabhängige boolesche Zeichenfolgen für die Kulturen Englisch (USA), Französisch (Frankreich) und Russisch (Russisch) bereitzustellen.

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, Convert um Konvertierungen zwischen einem Boolean Wert und einem anderen primitiven Typ in .NET durchzuführen, oder Sie können die Boolean expliziten Implementierungen der Struktur aufrufen. Konvertierungen zwischen einem und den folgenden Typen werden jedoch Boolean nicht unterstützt, sodass die entsprechenden Konvertierungsmethoden eine InvalidCastException Ausnahme auslösen:

Bei allen Konvertierungen von ganzzahligen Zahlen oder Gleitkommazahlen in boolesche Werte werden Werte ungleich 0 (null) in true und Nullwerte in false konvertiert. Im folgenden Beispiel wird dies durch Aufrufen ausgewählter Überladungen der Convert.ToBoolean -Klasse 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 Convert -Klasse true in 1 und false in 0 konvertiert. Visual Basic Konvertierungsfunktionen werden jedoch true entweder in 255 (für Konvertierungen in Byte Werte) oder -1 (für alle anderen numerischen Konvertierungen) konvertiert. Im folgenden Beispiel wird true mithilfe einer -Methode in numerische Werte Convert konvertiert, und im Fall des Visual Basic Beispiels mithilfe des eigenen Konvertierungsoperators der 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 von booleschen Werten. Informationen zu Konvertierungen von Zeichenfolgen in Boolean Werte finden Sie im Abschnitt Analysieren von booleschen Werten.

Analysieren von booleschen Werten

Die Boolean -Struktur enthält zwei statische Analysemethoden, Parse und , die eine Zeichenfolge in einen TryParse 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 Äquivalente mit gemischter Schreibweise. Numerische Zeichenfolgen wie "0" oder "1" können nicht erfolgreich analysiert werden. Führende oder nachfolgende Leerzeichen werden beim Ausführen des Zeichenfolgenvergleichs nicht berücksichtigt.

Im folgenden Beispiel werden die -Methode und die Parse TryParse -Methode verwendet, um eine Reihe von Zeichenfolgen zu analysieren. Beachten Sie, dass nur die Entsprechungen "True" und "False" ohne Beachtung der 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 Visual Basic programmieren, können Sie die -Funktion verwenden, CBool um die Zeichenfolgendarstellung einer Zahl in einen booleschen Wert zu konvertieren. "0" wird in false konvertiert, und die Zeichenfolgendarstellung eines beliebigen Werts ungleich 0 (null) wird in true konvertiert. Wenn Sie nicht in Visual Basic programmieren, müssen Sie Ihre numerische Zeichenfolge in eine Zahl konvertieren, bevor Sie sie in einen booleschen Wert konvertieren. Im folgenden Beispiel wird dies durch Konvertieren eines Arrays von ganzen Zahlen in boolesche Werte veranschaulicht.

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 true oder false sind, gibt es wenig Grund, die -Methode explizit CompareTo aufzurufen, die angibt, ob eine Instanz größer als, kleiner oder gleich einem angegebenen Wert ist. Um zwei boolesche Variablen zu vergleichen, rufen Sie in der Regel die -Methode auf oder verwenden den Equals Gleichheitsoperator Ihrer Sprache.

Wenn Sie jedoch eine boolesche Variable mit dem literalen booleschen Wert oder vergleichen true false möchten, ist kein expliziter Vergleich erforderlich, da das Ergebnis der Auswertung eines booleschen Werts dieser boolesche Wert 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 Booleschen Werten als binäre Werte

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 Bit mit niedriger Reihenfolge des Byte wird verwendet, um seinen Wert darzustellen. 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 Sätzen boolescher Werte zu arbeiten.

Sie können einen booleschen Wert in seine binäre Darstellung konvertieren, indem Sie die BitConverter.GetBytes(Boolean) -Methode 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 BitConverter.ToBoolean(Byte[], Int32) -Methode aufrufen.

Das folgende Beispiel ruft die BitConverter.GetBytes -Methode auf, um einen booleschen Wert in seine binäre Darstellung zu konvertieren, zeigt die einzelnen Bits des Werts an und ruft dann die BitConverter.ToBoolean -Methode auf, um den Wert aus seiner binären Darstellung 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. Die zweite veranschaulicht die Verwendung für arithmetische Operationen.

Boolesche Werte als Flags

Boolesche Variablen werden am häufigsten als Flags verwendet, um das Vorhandensein oder Fehlen einer Bedingung zu signalisieren. In der String.Compare(String, String, Boolean) -Methode ist beispielsweise der letzte Parameter, ignoreCase , ein Flag, das angibt, ob beim Vergleich von zwei Zeichenfolgen die Groß-/Kleinschreibung nicht beachtet wird ( ignoreCase ist ) oder die true Groß-/Kleinschreibung beachtet wird ( ignoreCase ist false ). Der Wert des Flags kann dann in einer bedingten 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 Switch) umzuleiten /f und die Ausgabe sowohl an eine angegebene Datei als auch an die Konsole (den Schalter) zu /b senden. Die App definiert ein Flag mit dem Namen isRedirected , um anzugeben, ob die Ausgabe an eine Datei gesendet werden soll, und ein Flag mit dem Namen isBoth , um anzugeben, dass die Ausgabe an die 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

Boolesche und arithmetische Operationen

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

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

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

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.

Boolesche Daten und Interop

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

Enumerationstyp Nicht verwaltetes Format
UnmanagedType.Bool Ein 4-Byte-Ganzzahlwert, wobei jeder Wert ungleich 0 true und 0 für false steht. Dies ist das Standardformat eines Boolean Felds in einer Struktur und eines Boolean Parameters in Plattformaufrufen.
UnmanagedType.U1 Ein ganzzahliger 1-Byte-Wert, wobei 1 true und 0 false darstellt.
UnmanagedType.VariantBool Ein 2-Byte-Ganzzahlwert, wobei -1 true und 0 für false steht. 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 threadsicherheit zu gewährleisten.