Boolean Boolean Boolean Boolean Struct

Definition

Stellt einen booleschen Wert dar (true oder false).Represents a Boolean (true or false) value.

public value class Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
type bool = struct
    interface IConvertible
Public Structure Boolean
Implements IComparable, IComparable(Of Boolean), IConvertible, IEquatable(Of Boolean)
Vererbung
Attribute
Implementiert

Hinweise

Eine Boolean -Instanz kann einen von zwei Werten aufweisen true:, falseoder.A Boolean instance can have either of two values: true, or false.

Die Boolean -Struktur stellt Methoden bereit, die die folgenden Aufgaben unterstützen:The Boolean structure provides methods that support the following tasks:

In den folgenden Abschnitten werden diese Aufgaben und andere Verwendungs Details erläutert:The following sections explain these tasks and other usage details:

Formatieren von booleschen Werten Formatting Boolean values
Konvertiert in und aus booleschen Werten Converting to and from Boolean values
Auswerten von booleschen Werten Parsing Boolean values
Vergleichen von booleschen Werten Comparing Boolean values
Arbeiten mit booleschen Werten als binäre Werte Working with Booleans as binary values
Ausführen von Vorgängen mit booleschen Werten Performing operations with Boolean values
Boolesche Werte und InteropBooleans and Interop

Formatieren von booleschen WertenFormatting Boolean values

Die Zeichen folgen Darstellung eines Boolean ist entweder "true" für einen true Wert oder "false" für einen false Wert.The string representation of a Boolean is either "True" for a true value or "False" for a false value. Die Zeichen folgen Darstellung eines Boolean Werts wird durch die TrueString schreibgeschützten Felder und FalseString definiert.The string representation of a Boolean value is defined by the read-only TrueString and FalseString fields.

Sie verwenden die ToString -Methode, um boolesche Werte in Zeichen folgen zu konvertieren.You use the ToString method to convert Boolean values to strings. Die boolesche Struktur enthält zwei ToString über Ladungen: die Parameter lose ToString() -Methode und die ToString(IFormatProvider) -Methode, die einen Parameter enthält, der die Formatierung steuert.The Boolean structure includes two ToString overloads: the parameterless ToString() method and the ToString(IFormatProvider) method, which includes a parameter that controls formatting. Da dieser Parameter jedoch ignoriert wird, werden die beiden über Ladungen identische Zeichen folgen liefern.However, because this parameter is ignored, the two overloads produce identical strings. Die ToString(IFormatProvider) -Methode unterstützt keine Kultur abhängige Formatierung.The ToString(IFormatProvider) method does not support culture-sensitive formatting.

Im folgenden Beispiel wird die Formatierung mit ToString der-Methode veranschaulicht.The following example illustrates formatting with the ToString method. Beachten Sie, dass im Beispiel das Feature für die kombinierte Formatierung verwendet wird, sodass die ToString -Methode implizit aufgerufen wird.Note that the example uses the composite formatting feature, so the ToString method is called implicitly.

using System;

public class Example
{
   public static void Main()
   {
      bool raining = false;
      bool busLate = true;

      Console.WriteLine("It is raining: {0}", raining);
      Console.WriteLine("The bus is late: {0}", busLate);
   }
}
// The example displays the following output:
//       It is raining: False
//       The bus is late: True
Module Example
   Public Sub Main()
      Dim raining As Boolean = False
      Dim busLate As Boolean = True

      Console.WriteLine("It is raining: {0}", raining)
      Console.WriteLine("The bus is late: {0}", busLate)
   End Sub
End Module
' The example displays the following output:
'       It is raining: False
'       The bus is late: True

Da die Boolean Struktur nur zwei Werte aufweisen kann, ist es einfach, benutzerdefinierte Formatierung hinzuzufügen.Because the Boolean structure can have only two values, it is easy to add custom formatting. Für eine einfache benutzerdefinierte Formatierung, bei der andere Zeichenfolgenliterale durch "true" und "false" ersetzt werden, können Sie alle von Ihrer Sprache unterstützten bedingten Auswertungsfunktionen C# verwenden, z. b. den bedingten Operator in oder den If-Operator in Visual Basic.For simple custom formatting in which other string literals are substituted for "True" and "False", you can use any conditional evaluation feature supported by your language, such as the conditional operator in C# or the If operator in Visual Basic. Im folgenden Beispiel wird diese Technik verwendet, Boolean um Werte als "yes" und "No" anstelle von "true" und "false" zu formatieren.The following example uses this technique to format Boolean values as "Yes" and "No" rather than "True" and "False".

using System;

public class Example
{
   public static void Main()
   {
      bool raining = false;
      bool busLate = true;

      Console.WriteLine("It is raining: {0}", 
                        raining ? "Yes" : "No");
      Console.WriteLine("The bus is late: {0}", 
                        busLate ? "Yes" : "No" );
   }
}
// The example displays the following output:
//       It is raining: No
//       The bus is late: Yes
Module Example
   Public Sub Main()
      Dim raining As Boolean = False
      Dim busLate As Boolean = True

      Console.WriteLine("It is raining: {0}", 
                        If(raining, "Yes", "No"))
      Console.WriteLine("The bus is late: {0}", 
                        If(busLate, "Yes", "No"))
   End Sub
End Module
' The example displays the following output:
'       It is raining: No
'       The bus is late: Yes

Für komplexere benutzerdefinierte Formatierungs Vorgänge, einschließlich Kultur abhängiger Formatierung, können Sie die String.Format(IFormatProvider, String, Object[]) -Methode aufzurufen ICustomFormatter und eine-Implementierung bereitstellen.For more complex custom formatting operations, including culture-sensitive formatting, you can call the String.Format(IFormatProvider, String, Object[]) method and provide an ICustomFormatter implementation. Im folgenden Beispiel werden die ICustomFormatter - IFormatProvider Schnittstellen und die-Schnittstelle implementiert, um Kultur abhängige boolesche Zeichen folgen für die Kulturen Englisch (USA), Französisch (Frankreich) und Russisch (Russische Föderation) bereitzustellen.The following example implements the ICustomFormatter and IFormatProvider interfaces to provide culture-sensitive Boolean strings for the English (United States), French (France), and Russian (Russia) cultures.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "", "en-US", "fr-FR", "ru-RU" };
      foreach (var cultureName in cultureNames) {
         bool value = true;
         CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
         BooleanFormatter formatter = new BooleanFormatter(culture);
         
         String result = String.Format(formatter, "Value for '{0}': {1}", culture.Name, value);
         Console.WriteLine(result);
      }
   }
}

public class BooleanFormatter : ICustomFormatter, IFormatProvider
{   
   private CultureInfo culture;
   
   public BooleanFormatter() : this(CultureInfo.CurrentCulture)
   { }
   
   public BooleanFormatter(CultureInfo culture)
   {
      this.culture = culture; 
   }
   
   public Object GetFormat(Type formatType)
   { 
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }
   
   public String Format(String fmt, Object arg, IFormatProvider formatProvider)
   { 
      // Exit if another format provider is used.
      if (! formatProvider.Equals(this)) return null;
      
      // Exit if the type to be formatted is not a Boolean
      if (! (arg is Boolean)) return null;
      
      bool value = (bool) arg;
      switch (culture.Name) {
         case "en-US":
            return value.ToString();
         case "fr-FR":
            if (value) 
               return "vrai";
            else
               return "faux";
         case "ru-RU":
            if (value)
               return "верно";
            else
               return "неверно";
         default:
            return value.ToString();  
      }
   }
}
// The example displays the following output:
//       Value for '': True
//       Value for 'en-US': True
//       Value for 'fr-FR': vrai
//       Value for 'ru-RU': верно
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "", "en-US", "fr-FR", "ru-RU" }
      For Each cultureName In cultureNames
         Dim value As Boolean = True
         Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
         Dim formatter As New BooleanFormatter(culture)
         
         Dim result As String = String.Format(formatter, "Value for '{0}': {1}", culture.Name, value)
         Console.WriteLine(result)
      Next
   End Sub
End Module

Public Class BooleanFormatter 
   Implements ICustomFormatter, IFormatProvider
   
   Private culture As CultureInfo
   
   Public Sub New()
      Me.New(CultureInfo.CurrentCulture)
   End Sub
   
   Public Sub New(culture As CultureInfo)
      Me.culture = culture 
   End Sub
   
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If                
   End Function
   
   Public Function Format(fmt As String, arg As Object, 
                          formatProvider As IFormatProvider) As String _
                   Implements ICustomFormatter.Format
      ' Exit if another format provider is used.
      If Not formatProvider.Equals(Me) Then Return Nothing
      
      ' Exit if the type to be formatted is not a Boolean
      If Not TypeOf arg Is Boolean Then Return Nothing
      
      Dim value As Boolean = CBool(arg)
      Select culture.Name
         Case "en-US"
            Return value.ToString()
         Case "fr-FR"
            If value Then
               Return "vrai"
            Else
               Return "faux"
            End If      
         Case "ru-RU"
            If value Then
               Return "верно"
            Else
               Return "неверно"
            End If   
         Case Else
            Return value.ToString()  
      End Select
   End Function
End Class
' The example displays the following output:
'          Value for '': True
'          Value for 'en-US': True
'          Value for 'fr-FR': vrai
'          Value for 'ru-RU': верно

Optional können Sie Ressourcen Dateien zum Definieren kulturspezifischer boolescher Zeichen folgen verwenden.Optionally, you can use resource files to define culture-specific Boolean strings.

Konvertiert in und aus booleschen WertenConverting to and from Boolean values

Die Boolean -Struktur implementiert IConvertible die-Schnittstelle.The Boolean structure implements the IConvertible interface. Daher können Sie die Convert -Klasse verwenden, um Konvertierungen zwischen einem Boolean Wert und einem beliebigen anderen primitiven Typ im .NET Framework auszuführen, oder Sie können die expliziten Implementierungen der Boolean Struktur aufzurufen.As a result, you can use the Convert class to perform conversions between a Boolean value and any other primitive type in the .NET Framework, or you can call the Boolean structure's explicit implementations. Konvertierungen zwischen einem Boolean -und den folgenden Typen werden jedoch nicht unterstützt, sodass die entsprechenden Konvertierungs InvalidCastException Methoden eine Ausnahme auslösen:However, conversions between a Boolean and the following types are not supported, so the corresponding conversion methods throw an InvalidCastException exception:

Alle Konvertierungen von ganzzahligen oder Gleit Komma Zahlen in boolesche Werte konvertieren Werte ungleich 0 true (null) in falseund NULL-Werte in.All conversions from integral or floating-point numbers to Boolean values convert non-zero values to true and zero values to false. Dies wird im folgenden Beispiel veranschaulicht, indem die ausgewählten über Ladungen Convert.ToBoolean der-Klasse aufgerufen werden.The following example illustrates this by calling selected overloads of the Convert.ToBoolean class.

using System;

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

Beim Konvertieren von Gleit Komma Werten in boolesche Werte führen die Konvertierungs Methoden einen exakten Vergleich mit 0 (null) aus.When converting from floating-point values to Boolean values, the conversion methods perform an exact comparison with zero. Wenn der Gleit Komma Wert die Genauigkeit verloren hat, kann das Ergebnis unerwartet ausfallen.If the floating-point value has lost precision, the result can be unexpected. Dies wird im folgenden Beispiel veranschaulicht, in dem eine Double Variable, deren Wert 0 (null) sein sollte, in einen booleschen Wert konvertiert wird.This is illustrated in the following example, in which a Double variable whose value should be zero is converted to a Boolean value. Wie im Beispiel gezeigt, liegt true das Ergebnis daran, dass die wiederholten Ergänzungen von 0,2 zu einem Genauigkeits Verlust geführt haben.As the example shows, the result is true because repeated additions of 0.2 have resulted in a loss of precision.

Beim Konvertieren von booleschen Werten in numerische Werte werden die Konvertierungs Methoden Convert der- true Klasse in 1 false und in 0 konvertiert.When converting from Boolean to numeric values, the conversion methods of the Convert class convert true to 1 and false to 0. Visual Basic Konvertierungs Funktionen konvertieren true jedoch entweder in 255 (für Konvertierungen in Byte Werte) oder-1 (für alle anderen numerischen Konvertierungen).However, Visual Basic conversion functions convert true to either 255 (for conversions to Byte values) or -1 (for all other numeric conversions). Im folgenden Beispiel wird true mit einer Convert -Methode in numerische Werte konvertiert, und im Fall des Visual Basic Beispiels mit dem eigenen Konvertierungs Operator der Visual Basic Sprache.The following example converts true to numeric values by using a Convert method, and, in the case of the Visual Basic example, by using the Visual Basic language's own conversion operator.

using System;

public class Example
{
   public static void Main()
   {
      bool flag = true;
      
      byte byteValue;   
      byteValue = Convert.ToByte(flag);
      Console.WriteLine("{0} -> {1}", flag, byteValue);         
      
      sbyte sbyteValue;
      sbyteValue = Convert.ToSByte(flag);
      Console.WriteLine("{0} -> {1}", flag, sbyteValue);         

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

      int intValue;
      intValue = Convert.ToInt32(flag);
      Console.WriteLine("{0} -> {1}", flag, intValue);         
   }
}
// The example displays the following output:
//       True -> 1
//       True -> 1
//       True -> 1
//       True -> 1
Module Example
   Public Sub Main()
      Dim flag As Boolean = true
      
      Dim byteValue As Byte   
      byteValue = Convert.ToByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, byteValue, 
                                            byteValue.GetType().Name)         
      byteValue = CByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, byteValue, 
                                            byteValue.GetType().Name)         
      
      Dim sbyteValue As SByte
      sbyteValue = Convert.ToSByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue, 
                                            sbyteValue.GetType().Name)         
      sbyteValue = CSByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue, 
                                            sbyteValue.GetType().Name)         

      Dim dblValue As Double
      dblValue = Convert.ToDouble(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, dblValue, 
                                            dblValue.GetType().Name)         
      dblValue = CDbl(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, dblValue, 
                                            dblValue.GetType().Name)         

      Dim intValue As Integer
      intValue = Convert.ToInt32(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, intValue, 
                                            intValue.GetType().Name)         
      intValue = CInt(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, intValue, 
                                            intValue.GetType().Name)         
   End Sub
End Module
' The example displays the following output:
'       True -> 1 (Byte)
'       True -> 255 (Byte)
'       True -> 1 (SByte)
'       True -> -1 (SByte)
'       True -> 1 (Double)
'       True -> -1 (Double)
'       True -> 1 (Int32)
'       True -> -1 (Int32)

Informationen zu Konvertierungen von in Zeichen folgen Werte finden Sie im Abschnitt Boolean Formatieren von booleschen Werten .For conversions from Boolean to string values, see the Formatting Boolean Values section. Informationen zu Konvertierungen von Boolean Zeichen folgen in-Werte finden Sie im Abschnitt zum Untersuchen von booleschen Werten .For conversions from strings to Boolean values, see the Parsing Boolean Values section.

Auswerten von booleschen WertenParsing Boolean values

Die Boolean -Struktur enthält zwei statische-Methoden, Parse und TryParse, die eine Zeichenfolge in einen booleschen Wert konvertieren.The Boolean structure includes two static parsing methods, Parse and TryParse, that convert a string to a Boolean value. 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.The string representation of a Boolean value is defined by the case-insensitive equivalents of the values of the TrueString and FalseString fields, which are "True" and "False", respectively. Anders ausgedrückt: die einzigen Zeichen folgen, die erfolgreich analysiert werden, sind "true", "false", "true", "false" oder einige gemischte Entsprechung.In other words, the only strings that parse successfully are "True", "False", "true", "false", or some mixed-case equivalent. Numerische Zeichen folgen wie "0" oder "1" können nicht erfolgreich analysiert werden.You cannot successfully parse numeric strings such as "0" or "1". Beim Durchführen des Zeichen folgen Vergleichs werden keine führenden oder nachfolgenden Leerzeichen berücksichtigt.Leading or trailing white-space characters are not considered when performing the string comparison.

Im folgenden Beispiel wird die Parse - TryParse Methode und die-Methode verwendet, um eine Reihe von Zeichen folgen zu analysieren.The following example uses the Parse and TryParse methods to parse a number of strings. Beachten Sie, dass nur die Unterscheidung nach Groß-/Kleinschreibung von "true" und "false" analysiert werden können.Note that only the case-insensitive equivalents of "True" and "False" can be successfully parsed.

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { null, String.Empty, "True", "False", 
                          "true", "false", "    true    ", 
                           "TrUe", "fAlSe", "fa lse", "0",  
                          "1", "-1", "string" };
      // Parse strings using the Boolean.Parse method.                    
      foreach (var value in values) {
         try {
            bool flag = Boolean.Parse(value);
            Console.WriteLine("'{0}' --> {1}", value, flag);
         }
         catch (ArgumentException) {
            Console.WriteLine("Cannot parse a null string.");
         }   
         catch (FormatException) {
            Console.WriteLine("Cannot parse '{0}'.", value);
         }         
      }
      Console.WriteLine();
      // Parse strings using the Boolean.TryParse method.                    
      foreach (var value in values) {
         bool flag = false;
         if (Boolean.TryParse(value, out flag))
            Console.WriteLine("'{0}' --> {1}", value, flag);
         else
            Console.WriteLine("Unable to parse '{0}'", value);
      }                                     
   }
}
// The example displays the following output:
//       Cannot parse a null string.
//       Cannot parse ''.
//       'True' --> True
//       'False' --> False
//       'true' --> True
//       'false' --> False
//       '    true    ' --> True
//       'TrUe' --> True
//       'fAlSe' --> False
//       Cannot parse 'fa lse'.
//       Cannot parse '0'.
//       Cannot parse '1'.
//       Cannot parse '-1'.
//       Cannot parse 'string'.
//       
//       Unable to parse ''
//       Unable to parse ''
//       'True' --> True
//       'False' --> False
//       'true' --> True
//       'false' --> False
//       '    true    ' --> True
//       'TrUe' --> True
//       'fAlSe' --> False
//       Cannot parse 'fa lse'.
//       Unable to parse '0'
//       Unable to parse '1'
//       Unable to parse '-1'
//       Unable to parse 'string'
Module Example
   Public Sub Main()
      Dim values() As String = { Nothing, String.Empty, "True", "False", 
                                 "true", "false", "    true    ", 
                                 "TrUe", "fAlSe", "fa lse", "0", 
                                 "1", "-1", "string" }
      ' Parse strings using the Boolean.Parse method.                    
      For Each value In values
         Try
            Dim flag As Boolean = Boolean.Parse(value)
            Console.WriteLine("'{0}' --> {1}", value, flag)
         Catch e As ArgumentException
            Console.WriteLine("Cannot parse a null string.")
         Catch e As FormatException
            Console.WriteLine("Cannot parse '{0}'.", value)
         End Try         
      Next  
      Console.WriteLine()
      ' Parse strings using the Boolean.TryParse method.                    
      For Each value In values
         Dim flag As Boolean = False
         If Boolean.TryParse(value, flag)
            Console.WriteLine("'{0}' --> {1}", value, flag)
         Else
            Console.WriteLine("Cannot parse '{0}'.", value)
         End If         
      Next  
   End Sub
End Module
' The example displays the following output:
'       Cannot parse a null string.
'       Cannot parse ''.
'       'True' --> True
'       'False' --> False
'       'true' --> True
'       'false' --> False
'       '    true    ' --> True
'       'TrUe' --> True
'       'fAlSe' --> False
'       Cannot parse 'fa lse'.
'       Cannot parse '0'.
'       Cannot parse '1'.
'       Cannot parse '-1'.
'       Cannot parse 'string'.
'       
'       Unable to parse ''
'       Unable to parse ''
'       'True' --> True
'       'False' --> False
'       'true' --> True
'       'false' --> False
'       '    true    ' --> True
'       'TrUe' --> True
'       'fAlSe' --> False
'       Cannot parse 'fa lse'.
'       Unable to parse '0'
'       Unable to parse '1'
'       Unable to parse '-1'
'       Unable to parse 'string'

Wenn Sie in Visual Basic programmieren, können Sie die CBool -Funktion verwenden, um die Zeichen folgen Darstellung einer Zahl in einen booleschen Wert zu konvertieren.If you are programming in Visual Basic, you can use the CBool function to convert the string representation of a number to a Boolean value. "0" wird in falsekonvertiert, und die Zeichen folgen Darstellung eines Werts ungleich NULL wird in truekonvertiert."0" is converted to false, and the string representation of any non-zero value is converted to true. Wenn Sie nicht in Visual Basic programmieren, müssen Sie die numerische Zeichenfolge in eine Zahl konvertieren, bevor Sie Sie in einen booleschen Wert konvertieren.If you are not programming in Visual Basic, you must convert your numeric string to a number before converting it to a Boolean. Dies wird im folgenden Beispiel veranschaulicht, indem ein Array von ganzen Zahlen in boolesche Werte konvertiert wird.The following example illustrates this by converting an array of integers to Boolean values.

using System;

public class Example
{
   public static void Main()
   {
      String[] values = { "09", "12.6", "0", "-13 " };
      foreach (var value in values) {
         bool success, result;
         int number; 
         success = Int32.TryParse(value, out number);
         if (success) {
            // The method throws no exceptions.
            result = Convert.ToBoolean(number);
            Console.WriteLine("Converted '{0}' to {1}", value, result);
         }
         else {
            Console.WriteLine("Unable to convert '{0}'", value); 
         }         
      }
   }
}
// The example displays the following output:
//       Converted '09' to True
//       Unable to convert '12.6'
//       Converted '0' to False
//       Converted '-13 ' to True
Module Example
   Public Sub Main()
      Dim values() As String = { "09", "12.6", "0", "-13 " }
      For Each value In values
         Dim success, result As Boolean
         Dim number As Integer 
         success = Int32.TryParse(value, number)
         If success Then
            ' The method throws no exceptions.
            result = Convert.ToBoolean(number)
            Console.WriteLine("Converted '{0}' to {1}", value, result)
         Else
            Console.WriteLine("Unable to convert '{0}'", value)
         End If         
      Next
   End Sub
End Module
' The example displays the following output:
'       Converted '09' to True
'       Unable to convert '12.6'
'       Converted '0' to False
'       Converted '-13 ' to True

Vergleichen von booleschen WertenComparing Boolean values

Da boolesche Werte entweder true oder falsesind, gibt es kaum einen Grund, explizit die CompareTo -Methode aufzurufen, die angibt, ob eine Instanz größer als, kleiner oder gleich einem angegebenen Wert ist.Because Boolean values are either true or false, there is little reason to explicitly call the CompareTo method, which indicates whether an instance is greater than, less than, or equal to a specified value. Zum Vergleichen von zwei booleschen Variablen wird in der Regel die Equals -Methode aufgerufen oder der Gleichheits Operator ihrer Sprache verwendet.Typically, to compare two Boolean variables, you call the Equals method or use your language's equality operator.

Wenn Sie jedoch eine boolesche Variable mit dem literalen booleschen Wert true oder falsevergleichen möchten, ist es nicht erforderlich, einen expliziten Vergleich durchzuführen, da das Ergebnis der Auswertung eines booleschen Werts dieser boolesche Wert ist.However, when you want to compare a Boolean variable with the literal Boolean value true or false, it is not necessary to do an explicit comparison, because the result of evaluating a Boolean value is that Boolean value. Beispielsweise werden die AusdrückeFor example, the expressions

if (booleanValue) {
If booleanValue Then

undand

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.

sind äquivalent, aber die zweite ist kompakter.are equivalent, but the second is more compact. Beide Verfahren bieten jedoch eine vergleichbare Leistung.However, both techniques offer comparable performance.

Arbeiten mit booleschen Werten als binäre WerteWorking with Booleans as binary values

Ein boolescher Wert belegt ein Byte des Arbeitsspeichers, wie im C# folgenden Beispiel gezeigt.A Boolean value occupies one byte of memory, as the following C# example shows. Das Beispiel muss mit dem /unsafe -Switch kompiliert werden.The example must be compiled with the /unsafe switch.

using System;

public struct BoolStruct
{
   public bool flag1;
   public bool flag2;
   public bool flag3;
   public bool flag4;
   public bool flag5;
}

public class Example
{
   public static void Main()
   {
      unsafe {
         BoolStruct b = new BoolStruct();
         bool* addr = (bool*) &b;
         Console.WriteLine("Size of BoolStruct: {0}", sizeof(BoolStruct));
         Console.WriteLine("Field offsets:");
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag1 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag2 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag3 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag4 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag5 - addr);
      }
   }
}
// The example displays the following output:
//       Size of BoolStruct: 5
//       Field offsets:
//          flag1: 0
//          flag1: 1
//          flag1: 2
//          flag1: 3
//          flag1: 4

Das niedrig wertige Bit des Bytewerts wird zum darstellen seines Werts verwendet.The byte's low-order bit is used to represent its value. Der Wert 1 steht truefür. der Wert 0 steht falsefür.A value of 1 represents true; a value of 0 represents false.

Warnung

Sie können die System.Collections.Specialized.BitVector32 -Struktur verwenden, um mit Sätzen von booleschen Werten zu arbeiten.You can use the System.Collections.Specialized.BitVector32 structure to work with sets of Boolean values.

Sie können einen booleschen Wert in seine binäre Darstellung konvertieren, indem Sie BitConverter.GetBytes(Boolean) die-Methode aufrufen.You can convert a Boolean value to its binary representation by calling the BitConverter.GetBytes(Boolean) method. Die-Methode gibt ein Bytearray mit einem einzelnen-Element zurück.The method returns a byte array with a single element. Um einen booleschen Wert aus der binären Darstellung wiederherzustellen, können Sie die BitConverter.ToBoolean(Byte[], Int32) -Methode aufzurufen.To restore a Boolean value from its binary representation, you can call the BitConverter.ToBoolean(Byte[], Int32) method.

Im folgenden Beispiel wird die BitConverter.GetBytes -Methode aufgerufen, um einen booleschen Wert in seine binäre Darstellung zu konvertieren, und zeigt die einzelnen Bits des Werts an BitConverter.ToBoolean und ruft dann die-Methode auf, um den Wert aus der binären Darstellung wiederherzustellen.The following example calls the BitConverter.GetBytes method to convert a Boolean value to its binary representation and displays the individual bits of the value, and then calls the BitConverter.ToBoolean method to restore the value from its binary representation.

using System;

public class Example
{
   public static void Main()
   {
      bool[] flags = { true, false };
      foreach (var flag in flags) {
         // Get binary representation of flag.
         Byte value = BitConverter.GetBytes(flag)[0];
         Console.WriteLine("Original value: {0}", flag);
         Console.WriteLine("Binary value:   {0} ({1})", value, 
                           GetBinaryString(value));
         // Restore the flag from its binary representation.
         bool newFlag = BitConverter.ToBoolean( new Byte[] { value }, 0);
         Console.WriteLine("Restored value: {0}\n", flag);
      }
   }
   
   private static string GetBinaryString(Byte value)
   {
      String retVal = Convert.ToString(value, 2);
      return new String('0', 8 - retVal.Length) + retVal;
   }
}
// The example displays the following output:
//       Original value: True
//       Binary value:   1 (00000001)
//       Restored value: True
//       
//       Original value: False
//       Binary value:   0 (00000000)
//       Restored value: False
Module Example
   Public Sub Main()
      Dim flags() As Boolean = { True, False }
      For Each flag In flags
         ' Get binary representation of flag.
         Dim value As Byte = BitConverter.GetBytes(flag)(0)
         Console.WriteLine("Original value: {0}", flag)
         Console.WriteLine("Binary value:   {0} ({1})", value, 
                           GetBinaryString(value))
         ' Restore the flag from its binary representation.
         Dim newFlag As Boolean = BitConverter.ToBoolean( { value }, 0)
         Console.WriteLine("Restored value: {0}", flag)
         Console.WriteLine()
      Next
   End Sub
   
   Private Function GetBinaryString(value As Byte) As String
      Dim retVal As String = Convert.ToString(value, 2)
      Return New String("0"c, 8 - retVal.Length) + retVal
   End Function
End Module
' The example displays the following output:
'       Original value: True
'       Binary value:   1 (00000001)
'       Restored value: True
'       
'       Original value: False
'       Binary value:   0 (00000000)
'       Restored value: False

Ausführen von Vorgängen mit booleschen WertenPerforming operations with Boolean values

In diesem Abschnitt wird veranschaulicht, wie boolesche Werte in-Apps verwendet werden.This section illustrates how Boolean values are used in apps. Im ersten Abschnitt wird die Verwendung als Flag erläutert.The first section discusses its use as a flag. Das zweite Beispiel veranschaulicht die Verwendung von arithmetischen Vorgängen.The second illustrates its use for arithmetic operations.

Boolesche Werte als FlagsBoolean values as flags

Boolesche Variablen werden am häufigsten als Flags verwendet, um das vorhanden sein oder Nichtvorhandensein einer Bedingung zu signalisieren.Boolean variables are most commonly used as flags, to signal the presence or absence of some condition. Beispielsweise ist in der String.Compare(String, String, Boolean) -Methode der letzte ignoreCaseParameter,, ein Flag, das angibt, ob beim Vergleich von zwei Zeichen folgen die groß-ignoreCase /Kleinschreibung beachtet wird (istignoreCase true) oder die Groß-/Kleinschreibung beachtet wird (ist false).For example, in the String.Compare(String, String, Boolean) method, the final parameter, ignoreCase, is a flag that indicates whether the comparison of two strings is case-insensitive (ignoreCase is true) or case-sensitive (ignoreCase is false). Der Wert des Flags kann dann in einer Bedingungs Anweisung ausgewertet werden.The value of the flag can then be evaluated in a conditional statement.

Im folgenden Beispiel wird eine einfache Konsolen-App verwendet, um die Verwendung von booleschen Variablen als Flags zu veranschaulichen.The following example uses a simple console app to illustrate the use of Boolean variables as flags. Die APP akzeptiert Befehlszeilenparameter, die es ermöglichen, dass die Ausgabe an eine angegebene Datei ( /f den Switch) umgeleitet wird, und dass die Ausgabe sowohl an eine angegebene Datei als auch an die Konsole ( /b den Switch) gesendet werden kann.The app accepts command-line parameters that enable output to be redirected to a specified file (the /f switch), and that enable output to be sent both to a specified file and to the console (the /b switch). Die APP definiert ein Flag namens isRedirected , um anzugeben, ob die Ausgabe an eine Datei gesendet werden soll, und ein isBoth Flag mit dem Namen, das angibt, dass die Ausgabe an die Konsole gesendet werden soll.The app defines a flag named isRedirected to indicate whether output is to be sent to a file, and a flag named isBoth to indicate that output should be sent to the console.

using System;
using System.IO;
using System.Threading;

public class Example
{
   public static void Main()
   {
      // Initialize flag variables.
      bool isRedirected = false;
      bool isBoth = false; 
      String fileName = "";
      StreamWriter sw = null;
      
      // Get any command line arguments.
      String[] args = Environment.GetCommandLineArgs();
      // Handle any arguments.
      if (args.Length > 1) { 
         for (int ctr = 1; ctr < args.Length; ctr++) {
            String arg = args[ctr];
            if (arg.StartsWith("/") || arg.StartsWith("-")) {
               switch (arg.Substring(1).ToLower())
               {
                  case "f":
                     isRedirected = true;
                     if (args.Length < ctr + 2) {
                        ShowSyntax("The /f switch must be followed by a filename.");
                        return;
                     }
                     fileName = args[ctr + 1];
                     ctr++;
                     break;
                  case "b":
                     isBoth = true;
                     break;
                  default:
                     ShowSyntax(String.Format("The {0} switch is not supported", 
                                              args[ctr]));
                     return;
               }
            }   
         }
      }

      // If isBoth is True, isRedirected must be True.
      if (isBoth &&  ! isRedirected) { 
         ShowSyntax("The /f switch must be used if /b is used.");
         return;
      }

      // Handle output.
      if (isRedirected) {
         sw = new StreamWriter(fileName); 
         if (!isBoth)
            Console.SetOut(sw); 
      }     
      String msg = String.Format("Application began at {0}", DateTime.Now);
      Console.WriteLine(msg);
      if (isBoth) sw.WriteLine(msg);
      Thread.Sleep(5000);
      msg = String.Format("Application ended normally at {0}", DateTime.Now);
      Console.WriteLine(msg);
      if (isBoth) sw.WriteLine(msg);
      if (isRedirected) sw.Close();
   }
   
   private static void ShowSyntax(String errMsg)
   {
      Console.WriteLine(errMsg);
      Console.WriteLine("\nSyntax: Example [[/f <filename> [/b]]\n");
   }
}
Imports System.IO
Imports System.Threading

Module Example
   Public Sub Main()
      ' Initialize flag variables.
      Dim isRedirected, isBoth As Boolean 
      Dim fileName As String = ""
      Dim sw As StreamWriter = Nothing
      
      ' Get any command line arguments.
      Dim args() As String = Environment.GetCommandLineArgs()
      ' Handle any arguments.
      If args.Length > 1 Then
         For ctr = 1 To args.Length - 1
            Dim arg As String = args(ctr)
            If arg.StartsWith("/") OrElse arg.StartsWith("-") Then
               Select Case arg.Substring(1).ToLower()
                  Case "f"
                     isRedirected = True
                     If args.Length < ctr + 2 Then
                        ShowSyntax("The /f switch must be followed by a filename.")
                        Exit Sub
                     End If
                     fileName = args(ctr + 1)
                     ctr += 1
                  Case "b"
                     isBoth = True
                  Case Else
                     ShowSyntax(String.Format("The {0} switch is not supported", 
                                              args(ctr)))
                     Exit Sub
               End Select
            End If   
         Next
      End If

      ' If isBoth is True, isRedirected must be True.
      If isBoth And Not isRedirected Then 
         ShowSyntax("The /f switch must be used if /b is used.")
         Exit Sub
      End If

      ' Handle output.
      If isRedirected Then
         sw = New StreamWriter(fileName) 
         If Not IsBoth Then
            Console.SetOut(sw) 
         End If
      End If     
      Dim msg As String = String.Format("Application began at {0}", Date.Now)
      Console.WriteLine(msg)
      If isBoth Then sw.WriteLine(msg)
      Thread.Sleep(5000)
      msg = String.Format("Application ended normally at {0}", Date.Now)
      Console.WriteLine(msg)
      If isBoth Then sw.WriteLine(msg)
      If isRedirected Then sw.Close()
   End Sub
   
   Private Sub ShowSyntax(errMsg As String)
      Console.WriteLine(errMsg)
      Console.WriteLine()
      Console.WriteLine("Syntax: Example [[/f <filename> [/b]]")
      Console.WriteLine()
   End Sub
End Module

Boolesche Operationen und arithmetische OperationenBooleans and arithmetic operations

Ein boolescher Wert wird manchmal verwendet, um das vorhanden sein einer Bedingung anzugeben, die eine mathematische Berechnung auslöst.A Boolean value is sometimes used to indicate the presence of a condition that triggers a mathematical calculation. Beispielsweise kann eine hasShippingCharge Variable als Flag dienen, um anzugeben, ob Versandgebühren einem Rechnungsbetrag hinzugefügt werden sollen.For example, a hasShippingCharge variable might serve as a flag to indicate whether to add shipping charges to an invoice amount.

Da ein Vorgang mit einem false Wert keine Auswirkung auf das Ergebnis eines Vorgangs hat, ist es nicht notwendig, den booleschen Wert in einen ganzzahligen Wert zu konvertieren, der für die mathematische Operation verwendet werden soll.Because an operation with a false value has no effect on the result of an operation, it is not necessary to convert the Boolean to an integral value to use in the mathematical operation. Stattdessen können Sie bedingte Logik verwenden.Instead, you can use conditional logic.

Im folgenden Beispiel wird ein Betrag berechnet, der aus einem Teilergebnis, einer Versandkosten und einer optionalen dienstkosten besteht.The following example computes an amount that consists of a subtotal, a shipping charge, and an optional service charge. Die hasServiceCharge -Variable bestimmt, ob die Dienst Belastung angewendet wird.The hasServiceCharge variable determines whether the service charge is applied. Anstatt in einen hasServiceCharge numerischen Wert zu wandeln und ihn mit dem Betrag der Dienstgebühr zu multiplizieren, wird im Beispiel die bedingte Logik verwendet, um den Dienstgebühren Betrag (sofern zutreffend) hinzuzufügen.Instead of converting hasServiceCharge to a numeric value and multiplying it by the amount of the service charge, the example uses conditional logic to add the service charge amount if it is applicable.

using System;

public class Example
{
   public static void Main()
   {
      bool[] hasServiceCharges = { true, false };
      Decimal subtotal = 120.62m;
      Decimal shippingCharge = 2.50m;
      Decimal serviceCharge = 5.00m;
      
      foreach (var hasServiceCharge in hasServiceCharges) {
         Decimal total = subtotal + shippingCharge + 
                                (hasServiceCharge ? serviceCharge : 0);
         Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.", 
                           total, hasServiceCharge);                       
      }
   }
}
// The example displays output like the following:
//       hasServiceCharge = True: The total is $128.12.
//       hasServiceCharge = False: The total is $123.12.
Module Example
   Public Sub Main()
      Dim hasServiceCharges() As Boolean = { True, False }
      Dim subtotal As Decimal = 120.62d
      Dim shippingCharge As Decimal = 2.50d
      Dim serviceCharge As Decimal = 5.00d
      
      For Each hasServiceCharge In hasServiceCharges
         Dim total As Decimal = subtotal + shippingCharge + 
                                If(hasServiceCharge, serviceCharge, 0)
         Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.", 
                           total, hasServiceCharge)                       
      Next
   End Sub
End Module
' The example displays output like the following:
'       hasServiceCharge = True: The total is $128.12.
'       hasServiceCharge = False: The total is $123.12.

Boolesche Werte und InteropBooleans and interop

Während das Marshalling von Basis Datentypen zu com in der Regel Boolean unkompliziert ist, ist der Datentyp eine Ausnahme.While marshaling base data types to COM is generally straightforward, the Boolean data type is an exception. Sie können das MarshalAsAttribute -Attribut anwenden, um Boolean den Typ in eine der folgenden Darstellungen zu Mars Hallen:You can apply the MarshalAsAttribute attribute to marshal the Boolean type to any of the following representations:

EnumerationstypEnumeration type Nicht verwaltetes FormatUnmanaged format
UnmanagedType.Bool Ein 4-Byte-ganzzahliger Wert, bei dem ein true Wert ungleich 0 false(null) darstellt und 0 darstellt.A 4-byte integer value, where any nonzero value represents true and 0 represents false. Dies ist das Standardformat eines Boolean Felds in einer Struktur und Boolean eines Parameters in Platt Form aufrufen.This is the default format of a Boolean field in a structure and of a Boolean parameter in platform invoke calls.
UnmanagedType.U1 Ein 1-Byte-ganzzahliger Wert, bei true dem die 1 falsedarstellt und 0 darstellt.A 1-byte integer value, where the 1 represents true and 0 represents false.
UnmanagedType.VariantBool Ein ganzzahliger 2-Byte-Wert, bei true dem-1 falsedarstellt und 0 darstellt.A 2-byte integer value, where -1 represents true and 0 represents false. Dies ist das Standardformat eines Boolean Parameters in COM-Interop-aufrufen.This is the default format of a Boolean parameter in COM interop calls.

Felder

FalseString FalseString FalseString FalseString

Stellt den booleschen Wert false als eine Zeichenfolge dar.Represents the Boolean value false as a string. Dieses Feld ist schreibgeschützt.This field is read-only.

TrueString TrueString TrueString TrueString

Stellt den booleschen Wert true als eine Zeichenfolge dar.Represents the Boolean value true as a string. Dieses Feld ist schreibgeschützt.This field is read-only.

Methoden

CompareTo(Boolean) CompareTo(Boolean) CompareTo(Boolean) CompareTo(Boolean)

Vergleicht diese Instanz mit einem angegebenen Boolean-Objekt und gibt eine ganze Zahl zurück, die ihre Beziehung untereinander angibt.Compares this instance to a specified Boolean object and returns an integer that indicates their relationship to one another.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die ihre Beziehung untereinander angibt.Compares this instance to a specified object and returns an integer that indicates their relationship to one another.

Equals(Boolean) Equals(Boolean) Equals(Boolean) Equals(Boolean)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Boolean-Objekt ist.Returns a value indicating whether this instance is equal to a specified Boolean object.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Gibt den Hashcode für diese Instanz zurück.Returns the hash code for this instance.

GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

Gibt den Typcode für den Boolean-Werttyp zurück.Returns the type code for the Boolean value type.

Parse(ReadOnlySpan<Char>) Parse(ReadOnlySpan<Char>) Parse(ReadOnlySpan<Char>) Parse(ReadOnlySpan<Char>)
Parse(String) Parse(String) Parse(String) Parse(String)

Konvertiert die angegebene Zeichenfolgendarstellung eines logischen Werts in seine Boolean-Entsprechung.Converts the specified string representation of a logical value to its Boolean equivalent.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung (entweder „True“ oder „False“).Converts the value of this instance to its equivalent string representation (either "True" or "False").

ToString() ToString() ToString() ToString()

Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung (entweder „True“ oder „False“).Converts the value of this instance to its equivalent string representation (either "True" or "False").

TryFormat(Span<Char>, Int32) TryFormat(Span<Char>, Int32) TryFormat(Span<Char>, Int32) TryFormat(Span<Char>, Int32)
TryParse(ReadOnlySpan<Char>, Boolean) TryParse(ReadOnlySpan<Char>, Boolean) TryParse(ReadOnlySpan<Char>, Boolean) TryParse(ReadOnlySpan<Char>, Boolean)
TryParse(String, Boolean) TryParse(String, Boolean) TryParse(String, Boolean) TryParse(String, Boolean)

Versucht, die angegebene Zeichenfolgendarstellung eines logischen Werts in die Boolean-Entsprechung zu konvertieren.Tries to convert the specified string representation of a logical value to its Boolean equivalent. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.A return value indicates whether the conversion succeeded or failed.

Explizite Schnittstellenimplementierungen

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

Eine Beschreibung dieses Members finden Sie unter ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

Diese Konvertierung wird nicht unterstützt.This conversion is not supported. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

Diese Konvertierung wird nicht unterstützt.This conversion is not supported. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

Eine Beschreibung dieses Members finden Sie unter ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

Eine Beschreibung dieses Members finden Sie unter ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

Gilt für:

Threadsicherheit

Alle Member dieses Typs sind Thread sicher.All members of this type are thread safe. Member, die scheinbar den Instanzzustand ändern, geben tatsächlich eine neue Instanz zurück, die mit dem neuen Wert initialisiert wurde.Members that appear to modify instance state actually return a new instance initialized with the new value. 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 Thread Sicherheit zu gewährleisten.As with any other type, reading and writing to a shared variable that contains an instance of this type must be protected by a lock to guarantee thread safety.