(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

Boolean-Struktur

Stellt einen booleschen Wert (true oder false) dar.

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

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

Der Boolean-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompareTo(Boolean)Vergleicht diese Instanz mit einem angegebenen Boolean-Objekt und gibt eine ganze Zahl zurück, die ihre Beziehung untereinander angibt.
Öffentliche MethodeUnterstützt von XNA FrameworkCompareTo(Object)Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die ihre Beziehung untereinander angibt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(Boolean)Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Boolean-Objekt ist.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(Object)Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist. (Überschreibt ValueType.Equals(Object).)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetHashCodeGibt den Hashcode für diese Instanz zurück. (Überschreibt ValueType.GetHashCode().)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkGetTypeCodeGibt den TypeCode für den Werttyp Boolean zurück.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsParseKonvertiert die angegebene Zeichenfolgendarstellung eines logischen Werts in die Boolean-Entsprechung oder löst eine Ausnahme aus, wenn die Zeichenfolge nicht gleich dem Wert von Boolean.TrueString oder Boolean.FalseString ist.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToString()Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung (entweder "True" oder "False"). (Überschreibt ValueType.ToString().)
Öffentliche MethodeUnterstützt von XNA FrameworkToString(IFormatProvider)Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung (entweder "True" oder "False").
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsTryParseVersucht, die angegebene Zeichenfolgendarstellung eines logischen Werts in die Boolean-Entsprechung zu konvertieren. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
Zum Seitenanfang

  NameBeschreibung
Öffentliches FeldStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsFalseStringStellt den booleschen Wert false als eine Zeichenfolge dar. Dieses Feld ist schreibgeschützt.
Öffentliches FeldStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsTrueStringStellt den booleschen Wert true als eine Zeichenfolge dar. Dieses Feld ist schreibgeschützt.
Zum Seitenanfang

  NameBeschreibung
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIComparable.CompareToInfrastruktur. 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.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToBooleanInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToBoolean.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToByteInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToByte.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToCharInfrastruktur. Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToDateTimeInfrastruktur. Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToDecimalInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToDecimal.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToDoubleInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToDouble.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToInt16Infrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToInt16.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToInt32Infrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToInt32.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToInt64Infrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToInt64.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToSByteInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToSByte.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToSingleInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToSingle.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToTypeInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToType.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToUInt16Infrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToUInt16.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToUInt32Infrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToUInt32.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToUInt64Infrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToUInt64.
Zum Seitenanfang

Eine Boolean-Instanz kann einen von zwei Werten haben: 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 and TryParse

  • Vergleichen von Werten: CompareTo und Equals

In den folgenden Abschnitten werden diese Aufgaben und andere Verwendungsdetails:

Formatieren von booleschen Werten
Konvertieren in und von booleschen Werten
Analysieren von booleschen Werten
Vergleichen von booleschen Werten
Verwenden von booleschen Werten als binären Werten
Ausführen von Vorgängen mit booleschen Werten

Formatieren von booleschen Werten

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

Sie verwenden die ToString-Methode, um boolesche Werte in Zeichenfolgen zu konvertieren. Die booleschen Struktur zwei Überladungen: ToString die parameterlose ToString()-Methode und die ToString(IFormatProvider)-Methode, die einen Parameter einschließt, der Formatierung steuert. Da dieser Parameter ignoriert wird, die zwei identische Zeichenfolgen des Überladungserzeugnisses. Die ToString(IFormatProvider)-Methode unterstützt nicht kulturabhängige Formatierung.

Das folgende Beispiel veranschaulicht die Formatierung mit der ToString-Methode. Beachten Sie, dass im Beispiel die kombinierte Formatierung-Funktion verwendet, sodass die ToString-Methode 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 nur zwei Werte verfügen kann, ist es einfach, benutzerdefinierte Formatierung hinzuzufügen. Für einfache benutzerdefinierte Formatierung, sodass andere Zeichenfolgenliterale für "true" und "False" ersetzt werden, können Sie eine bedingte Auswertungsfunktion verwenden, die von der Sprache, wie bedingter Operator in C# oder Wenn Operator in Visual Basic unterstützt wird. Im folgenden Beispiel wird diese Technik, Boolean als Werte "Ja" und "no" anstatt "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


Für komplexere benutzerdefinierte Formatierungsvorgänge einschließlich kulturabhängige Formatierung, können Sie die String.Format(IFormatProvider, String, Object[])-Methode aufrufen und eine ICustomFormatter Implementierung bereitstellen. Das nächste Beispiel implementiert die ICustomFormatter und IFormatProvider-Schnittstellen, um kulturabhängige boolesche Zeichenfolgen für die englischen (USA), Franzose- (Frankreich) und russischen(der 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 die Ressourcendateien verwenden, um kulturabhängige boolesche Zeichenfolgen definieren.

Konvertieren in und von booleschen Werten

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

Alle Konvertierungen von ganzzahligen oder Gleitkommazahlen zu boolesche Werte konvertieren Werte ungleich 0 (null) zu true-Werte 0 (null) mit false. Das folgende Beispiel veranschaulicht dies, indem ausgewählte Überladungen der Convert.ToBoolean-Klasse aufruft.


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


Bei der Konvertierung in Gleitkommawerte zu boolesche Werte, führen die Konvertierungsmethoden einen genauen Vergleich mit Nullen. Wenn der Gleitkommawert Genauigkeit verloren verfügt, kann das Ergebnis unerwartet auftreten. Dies wird im folgenden Beispiel veranschaulicht, in dem eine Double-Variable, deren Wert null sein soll, in einen booleschen Wert konvertiert wird. Da das Beispiel zeigt, ist das Ergebnis true, da wiederholte Hinzufügungen von 0,2 einen Genauigkeitsverlust lauten.

Bei der Konvertierung von booleschen Werts zu numerische Werte, konvertieren die Konvertierungsmethoden der Convert-Klasse true auf 1 und false auf 0. konvertieren jedoch Visual Basic-Konvertierungsfunktionen true entweder auf 255 (für Konvertierungen zu Byte-Werten) oder -1 (für alle anderen numerischen Konvertierungen). Im folgenden Beispiel konvertiert true zu den numerischen Werten, indem eine Convert-Methode und, im Fall des Visual Basic-Beispiels, indem der eigene Konvertierungsoperator der Visual Basic-Sprache verwendet.


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


Informationen zu Konvertierungen von Boolean in den Zeichenfolgenwerten finden Sie im Abschnitt Formatierungs-boolesche Werte. 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 TryParse, die eine Zeichenfolge in einen booleschen Wert konvertiert. Die Zeichenfolgendarstellung eines booleschen Werts wird von der die Groß-/Kleinschreibung keine Rolle Entsprechungen der Werte TrueString und FalseString Felder, die "True" und "False" sind, jeweils definiert. Das heißt, dass die beiden Zeichenfolgen, die die "True", "False", "true", "false" oder eine kombinierte Schreibungssentsprechung. Sie können numerische Zeichenfolgen beispielsweise wie "0" oder "1" nicht erfolgreich analysieren. Führende oder nachfolgende Leerzeichen werden nicht berücksichtigt, wenn von den Zeichenfolgenvergleich ausführt.

Im folgenden Beispiel wird die Parse und TryParse, um Methoden verschiedene Zeichenfolgen zu analysieren. Beachten Sie, dass nur die die Groß-/Kleinschreibung nicht beachtet Entsprechungen von "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 programmiert, können Sie die Funktion CBool verwenden, um die Zeichenfolgendarstellung einer Zahl in einen booleschen Wert zu konvertieren. "0" wird in false umgewandelt, und die Zeichenfolgendarstellung jedes beliebigen Wert ungleich 0 (null) wird in true umgewandelt. Wenn Sie in Visual Basic programmieren, müssen Sie die numerische Zeichenfolge in eine Zahl konvertieren, bevor Sie sie an einen booleschen Wert konvertiert. Das folgende Beispiel veranschaulicht dies, indem ein Array mit Ganzzahlen zu den booleschen Werten konvertiert.


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


Vergleichen von booleschen Werten

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

Wenn Sie eine boolesche Variable mit dem literalen booleschen Wert true oder false vergleichen möchten, ist es nicht erforderlich, eine explizite Vergleich auszuführen, da das Ergebnis des Auswertens eines booleschen Werts dieser boolesche Wert ist. Beispielsweise 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.


Sie sollten entsprechend, das zweite ist kompakter. bieten jedoch beide Verfahren vergleichbare Leistung an.

Verwenden von booleschen Werten als binären Werten

Ein boolescher Wert nimmt ein Byte des Arbeitsspeichers. Das dem niedrigsten Wert Bit des Bytes wird verwendet, um den Wert anzuzeigen. Ein Wert von 1 stellt true dar; ein Wert von 0 stellt false dar.

WarnhinweisVorsicht

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

Sie können eines booleschen Werts zu seiner Binärdarstellung konvertieren, indem Sie die BitConverter.GetBytes(Boolean)-Methode aufrufen. Die Methode gibt ein Bytearray mit einem einzelnen Element zurück. Um einen booleschen Wert von der binären Darstellung wiederherzustellen, können Sie die BitConverter.ToBoolean(Byte[], Int32)-Methode aufrufen.

Im folgenden Beispiel wird die Methode BitConverter.GetBytes auf, um eines booleschen Werts zu seiner Darstellung zu konvertieren und zeigt die einzelnen Bits des Werts an und ruft dann die BitConverter.ToBoolean-Methode auf, um den Wert von 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


Ausführen von Vorgängen mit booleschen Werten

Dieser Abschnitt veranschaulicht, z boolesche Werte in Apps verwendet werden. Der erste Abschnitt wird seine Verwendung als Flag. Das zweite wird seine Verwendung für arithmetische Operationen.

a28wyd50.collapse_all(de-de,VS.110).gifBoolesche Werte als Flags

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

Im folgenden Beispiel wird eine einfache Konsolen-App, um die Verwendung von booleschen Variablen als Flags zu veranschaulichen. Die App akzeptiert Befehlszeilenparameter, die die zum Aktivieren einer angegebenen Datei (der /f-Schalter) umgeleitet werden Ausgabe, und mit denen zu einer angegebenen Datei und der Konsole (der /b-Schalter) übermittelt werden, Ausgabe. Die App definiert ein Flag, das isRedirected, um anzugeben benannt werden, ob die Ausgabe zu einer Datei gesendet werden soll, und ein Flag anzugeben, das dem Namen isBoth, das 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");
   }
}


a28wyd50.collapse_all(de-de,VS.110).gifBoolesche Werte und arithmetische Operationen

Ein boolescher Wert wird auch verwendet, um dem Vorhandensein einer Bedingung anzugeben, die eine mathematische Berechnung auslöst. Beispielsweise diente möglicherweise eine hasShippingCharge-Variable als Flag anzugeben, ob Versandkosten einem Rechnungsbetrag hinzufügt.

Da ein Vorgang mit einem false-Wert keinen Einfluss auf das Ergebnis einer Operation verfügt, ist es nicht erforderlich, den booleschen Wert in einen ganzzahligen Wert konvertiert, um im mathematischen Vorgang zu verwenden. Sie können bedingte Logik verwenden.

Im folgenden Beispiel wird eine Menge, die einem einen, optionalen und Versandkosten aus Bearbeitungskosten besteht. Die hasServiceCharge-Variablen bestimmt, ob die Bearbeitungskosten angewendet werden. Anstatt, hasServiceCharge in einen numerischen Wert zu konvertieren und sie durch die Menge der Bearbeitungskosten zu multiplizierenden, die bedingte Logik der wird, um die Bearbeitungskostenmenge hinzuzufügen, wenn sie angewendet werden kann.


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.


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

.NET für Windows Phone-Apps

Unterstützt in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Alle Member dieses Typs sind threadsicher. Member, die scheinbar den Zustand einer Instanz ändern, geben in Wirklichkeit eine neue Instanz zurück, die mit dem neuen Wert initialisiert wurde. Wie bei allen anderen Typen müssen Lese- und Schreibzugriffe auf eine freigegebene Variable, die eine Instanz dieses Typs enthält, durch eine Sperre geschützt werden, um die Threadsicherheit zu gewährleisten.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft