Windows-Apps
Inhaltsverzeichnis reduzieren
Inhaltsverzeichnis erweitern
Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch
Informationen
Das angeforderte Thema wird unten angezeigt. Es ist jedoch nicht in dieser Bibliothek vorhanden.

Boolean-Struktur

 

Veröffentlicht: Oktober 2016

Stellt einen booleschen Wert dar (true oder false).

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Boolean : IComparable, IConvertible, IComparable<bool>, 
	IEquatable<bool>

NameBeschreibung
System_CAPS_pubmethodCompareTo(Boolean)

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

System_CAPS_pubmethodCompareTo(Object)

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

System_CAPS_pubmethodEquals(Boolean)

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

System_CAPS_pubmethodEquals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.(Überschreibt ValueType.Equals(Object).)

System_CAPS_pubmethodGetHashCode()

Gibt den Hashcode für diese Instanz zurück.(Überschreibt ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodGetTypeCode()

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

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

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

System_CAPS_pubmethodToString()

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

System_CAPS_pubmethodToString(IFormatProvider)

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

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Boolean)

Versucht, die angegebene Zeichenfolgendarstellung eines logischen Werts in die Boolean-Entsprechung zu konvertieren. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

NameBeschreibung
System_CAPS_pubfieldSystem_CAPS_staticFalseString

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

System_CAPS_pubfieldSystem_CAPS_staticTrueString

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

NameBeschreibung
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToUInt64.

Ein Boolean Instanzen können eine der beiden Werte aufweisen: true, oder false.

Die Boolean Struktur bietet Methoden, die die folgenden Aufgaben unterstützen:

  • Konvertieren von booleschen Werten in Zeichenfolgen:ToString

  • Analysieren von Zeichenfolgen, um sie in boolesche Werte konvertieren: Parse undTryParse

  • Vergleichen von Werten: CompareTo undEquals

Den folgenden Abschnitten werden diese Aufgaben und anderen Nutzungsdetails:

Formatieren von booleschen Werten
Konvertieren von booleschen Werten
Analysieren von booleschen Werten
Vergleichen von booleschen Werten
Arbeiten mit booleschen Werten als binäre Werte
Ausführen von Vorgängen mit booleschen Werten
Boolesche Werte und Interop

Die angegebene Zeichenfolgendarstellung einer Boolean ist entweder "True" für eine true Wert oder "False" für eine false Wert. Die angegebene Zeichenfolgendarstellung einer Boolean Wert wird durch die schreibgeschützte definiert TrueString und FalseString Felder.

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

Das folgende Beispiel veranschaulicht die Formatierung mit der ToString Methode. Hinweis, der im Beispiel wird die kombinierte Formatierung Funktion, sodass der ToString Methode wird implizit aufgerufen.

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

Da die Boolean Struktur kann nur zwei Werte aufweisen, es ist einfach, benutzerdefinierte Formatierung hinzufügen. Für einfache benutzerdefinierte Formatierung in die andere Zeichenfolge Literale für "True" und "False" ersetzt werden, können Sie eine beliebige bedingten Auswertung-Funktion, die von Ihrer Sprache unterstützt, z. B. die Bedingungsoperator in c# oder der Wenn Operator in Visual Basic. Im folgenden Beispiel wird diese Technik zum Formatieren Boolean Werte als "Yes" und "No" anstatt "True" und "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

Für komplexere benutzerdefinierte Formatierung Dienstvorgänge, einschließlich kulturabhängige Formatierung, rufen Sie die String.Format(IFormatProvider, String, Object[]) Methode, und geben Sie eine ICustomFormatter Implementierung. Das folgende Beispiel implementiert die ICustomFormatter und IFormatProvider Schnittstellen, um kulturabhängige booleschen Zeichenfolgen für Englisch (Vereinigte Staaten), Französisch (Frankreich) und Russisch (Russische Föderation) Kulturen 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': верно

Optional können Sie Ressourcendateien kulturspezifische booleschen Zeichenfolgen zu definieren.

Die Boolean Struktur implementiert die IConvertible Schnittstelle. Folglich können Sie die Convert Klasse zum Durchführen von Konvertierungen zwischen einer Boolean Wert und alle anderen primitiven Typen in .NET Framework, oder Sie können Aufrufen der Boolean -Struktur explizite Implementierungen. Allerdings Konvertierungen zwischen einer Boolean und die folgenden Typen werden nicht unterstützt, damit die entsprechenden Konvertierungsmethoden Auslösen einer InvalidCastException Ausnahme:

Alle Konvertierungen von ganzzahligen oder Gleitkomma-Zahlen, boolesche Werte konvertieren Werte ungleich NULL true und Nullwerte zu false. Das folgende Beispiel veranschaulicht dies durch Aufrufen der ausgewählten Überladungen der Convert.ToBoolean Klasse.

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

Beim Konvertieren von Gleitkommazahlen-Punktwerte in boolesche Werte führen Sie die Konvertierungsmethoden einen genauen Vergleich mit 0 (null). Wenn der Gleitkommawert mit einfacher Genauigkeit verloren hat, kann das Ergebnis nicht erwartet werden. Dies wird im folgenden Beispiel, in dem veranschaulicht eine Double Variable, deren Wert muss 0 (null) wird in einen booleschen Wert konvertiert. Wie das Beispiel zeigt, ist das Ergebnis true da wiederholt Ergänzungen von 0,2 in einem Genauigkeitsverlust zurückzuführen sein.

Beim Konvertieren in numerischen Werten, die Methoden für die Konvertierung von booleschen Wert der Convert Klasse Convert true auf 1 und false auf 0. Visual Basic-Konvertierungsfunktionen jedoch konvertieren true entweder 255 (für Konvertierungen in Byte Werte) oder -1 (für alle anderen numerischen Konvertierungen). Das folgende Beispiel konvertiert true in numerische Werte mit einer Convert -Methode, wenn es sich um die Visual Basic-Beispiel mithilfe des Visual Basic-Sprache des eigenen Konvertierungsoperators.

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

Für Konvertierungen von Boolean Zeichenfolgenwerte, finden Sie unter der boolesche Werte Formatierung Abschnitt. Für Konvertierungen von Zeichenfolgen in Boolean -Werte finden Sie in der boolesche Werte Analyse Abschnitt.

Die Boolean Struktur umfasst zwei statische Analysemethoden Parse und TryParse, eine Zeichenfolge in einen booleschen Wert konvertiert werden. 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. Das heißt, sind nur Zeichenfolgen, die erfolgreich analysiert "True", "False", "True", "False", oder einige Entsprechung gemischter Groß-. Numerische Zeichenfolgen wie z. B. "0" oder "1" kann nicht erfolgreich analysiert werden. Führende oder nachfolgende Leerzeichen werden bei der Zeichenfolgenvergleich durch, nicht beachtet.

Im folgenden Beispiel wird die Parse und TryParse Methoden zum Analysieren einer Zahl von Zeichenfolgen. Beachten Sie, dass nur die Groß-/Kleinschreibung Entsprechungen der "True" und "False" 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'

Wenn Sie in Visual Basic programmieren, können Sie mithilfe der CBool Funktion, um die Zeichenfolgendarstellung einer Zahl in einen booleschen Wert konvertiert. "0" wird konvertiert, um false, und konvertiert die Zeichenfolgendarstellung für einen beliebigen Wert ungleich NULL true. Wenn Sie nicht in Visual Basic programmieren, müssen Sie die numerische Zeichenfolge in eine Zahl konvertieren, vor der Konvertierung in einen booleschen Wert. Das folgende Beispiel veranschaulicht dies, indem Sie ein Array von Ganzzahlen in boolesche Werte konvertieren.

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

Da boolesche Werte entweder sind true oder false, es ist ratsam explizit aufrufen, die CompareTo Methode, die angibt, ob eine Instanz größer als, kleiner ist, oder mit einem angegebenen Wert übereinstimmt. Um zwei boolesche Variablen zu vergleichen, rufen Sie in der Regel die Equals Methode, oder verwenden Sie Ihre Sprache Gleichheitsoperator.

Jedoch, wenn Sie eine boolesche Variable mit dem literal booleschen Wert vergleichen möchten true oder false, es ist nicht notwendig, einen expliziten Vergleich führen, da das Ergebnis der Auswertung eines booleschen Werts, boolescher Wert ist. Angenommen, die Ausdrücke

if (booleanValue) {

und

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.

äquivalent sind, aber die zweite ist kompakter. Beide Verfahren bietet jedoch vergleichbare Leistung.

Ein boolescher Wert nimmt ein Byte des Arbeitsspeichers, wie im folgenden C#-Beispiel gezeigt. Das Beispiel kompiliert werden muss, mit der /unsafe wechseln.

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 Byte niederwertige Bit wird verwendet, um seinen Wert darzustellen. Der Wert 1 gibt true; ein Wert von 0 stellt false.

System_CAPS_warningWarnung

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

Sie können einen booleschen Wert in die binäre Darstellung konvertiert, durch Aufrufen der BitConverter.GetBytes(Boolean) Methode. Die Methode gibt ein Bytearray mit einem einzelnen Element zurück. Um einen booleschen Wert aus der binären Darstellung wiederherzustellen, rufen Sie die BitConverter.ToBoolean(Byte[], Int32) Methode.

Im folgenden Beispiel wird die BitConverter.GetBytes Methode, einen booleschen Wert in seine binäre Darstellung und zeigt die einzelnen Bits der Wert ein, und klicken Sie dann Aufrufe konvertieren die BitConverter.ToBoolean Methode, um den Wert aus der 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

In diesem Abschnitt wird veranschaulicht, wie boolesche Werte werden in apps verwendet. Der erste Abschnitt erläutert die Verwendung als ein Flag an. Die zweite veranschaulicht Verwendungsmöglichkeiten für arithmetische Operationen.

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

Im folgenden Beispiel wird eine einfache Konsolenanwendung veranschaulicht die Verwendung von booleschen Variablen als Flags. Die app akzeptiert Befehlszeilenparameter, mit denen Ausgabe an eine angegebene Datei umgeleitet werden können (die /f wechseln), und die Ausgabe in einer angegebenen Datei und in der Konsole an aktivieren (die /b wechseln). Die app definiert ein Flag, mit dem Namen isRedirected , um anzugeben, ob die Ausgabe an eine Datei gesendet werden, und ein Kennzeichen mit der Bezeichnung 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");
   }
}

Ein boolescher Wert wird manchmal verwendet, um das Vorhandensein einer Bedingung anzuzeigen, der eine mathematische Berechnung auslöst. Z. B. eine hasShippingCharge Variable möglicherweise dienen als ein Flag zur Angabe, ob ein Rechnungsbetrag Versandkosten hinzugefügt.

Da ein Vorgang mit einem false Wert hat keine Auswirkungen auf das Ergebnis eines Vorgangs, ist es nicht notwendig, konvertiert der boolesche Wert in einen ganzzahligen Wert in der mathematischen Vorgang verwendet. Stattdessen können Sie bedingten Logik verwenden.

Das folgende Beispiel berechnet einen Anteil, der ein Teilergebnis eine Versandgebühr und eine optionale Zuschlag besteht. Die hasServiceCharge Variable wird bestimmt, ob der Dienst kostenlos angewendet wird. Anstatt das Konvertieren von hasServiceCharge einen numerischen Wert und die Menge an den Dienst kostenlos multipliziert, im Beispiel wird bedingten Logik die Gebühren Menge hinzufügen, wenn es gilt.

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.

Beim Marshalling Basisdatentypen für COM in der Regel einfach ist, ist die Boolean -Datentyp ist eine Ausnahme. Können Sie anwenden der MarshalAsAttribute Attribut zum Marshallen der Boolean Typ auf eines der folgenden Darstellung:

Enumerationstyp

Nicht verwalteten Formats

UnmanagedType.Bool

Eine 4-Byte-Ganzzahl-Wert, wobei ein Wert ungleich NULL true und 0 stellt false. Dies ist das Standardformat für eine Boolean Feld in einer Struktur und des eine Boolean Parameter im Platform invoke-Aufrufe.

UnmanagedType.U1

Einen 1-Byte-Ganzzahl-Wert, wobei 1 true und 0 stellt false.

UnmanagedType.VariantBool

Eine 2-Byte-Ganzzahl-Wert, wobei-1 true und 0 stellt false. Dies ist das Standardformat von einem Boolean Parameter in COM-Interop-aufrufen.

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Alle Member dieses Typs sind threadsicher. Elemente, die angezeigt werden, so ändern Sie den Status der Anwendungsinstanz zurückgeben tatsächlich eine neue Instanz mit dem neuen Wert initialisiert. Als müssen mit einem beliebigen anderen Typ Lesen und Schreiben in eine freigegebene Variable, die eine Instanz dieses Typs enthält durch ein Schloss auf Threadsicherheit geschützt werden.

Zurück zum Anfang
Anzeigen:
© 2018 Microsoft