System.Boolean-Struktur
Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.
Eine Boolean Instanz kann einen von zwei Werten aufweisen: true oder false.
Die Boolean Struktur stellt Methoden bereit, die die folgenden Aufgaben unterstützen:
- Konvertieren boolescher Werte in Zeichenfolgen: ToString
- Analysieren von Zeichenfolgen zum Konvertieren in boolesche Werte: Parse und TryParse
- Vergleichen von Werten: CompareTo und Equals
In diesem Artikel werden diese Aufgaben und andere Verwendungsdetails erläutert.
Boolesche Werte formatieren
Die Zeichenfolgendarstellung einer Boolean ist entweder "True" für einen true Wert oder "False" für einen false Wert. Die Zeichenfolgendarstellung eines Boolean Werts wird durch schreibgeschützte TrueString Felder und FalseString Felder definiert.
Sie verwenden die ToString Methode, um boolesche Werte in Zeichenfolgen zu konvertieren. Die boolesche Struktur enthält zwei ToString Überladungen: die parameterlose ToString() Methode und die Methode, die ToString(IFormatProvider) einen Parameter enthält, der die Formatierung steuert. Da dieser Parameter jedoch ignoriert wird, erzeugen die beiden Überladungen identische Zeichenfolgen. Die ToString(IFormatProvider) Methode unterstützt keine kultursensitive Formatierung.
Im folgenden Beispiel wird die Formatierung mit der ToString Methode veranschaulicht. Beachten Sie, dass die C#- und VB-Beispiele das Zusammengesetztformatierungsfeature verwenden, während im F#-Beispiel Zeichenfolgeninterpolation verwendet wird. In beiden Fällen wird die ToString Methode implizit aufgerufen.
using System;
public class Example10
{
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
let raining = false
let busLate = true
printfn $"It is raining: {raining}"
printfn $"The bus is late: {busLate}"
// The example displays the following output:
// It is raining: False
// The bus is late: True
Module Example9
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 Formatierungen hinzuzufügen. Für einfache benutzerdefinierte Formatierungen, in denen andere Zeichenfolgenliterale durch "True" und "False" ersetzt werden, können Sie jedes feature für die bedingte Auswertung verwenden, das von Ihrer Sprache unterstützt wird, z. B. den bedingten Operator in C# oder den If-Operator in Visual Basic. Im folgenden Beispiel wird diese Technik verwendet, um Werte als "Ja" und "Nein" anstelle von "True" und "False" zu formatieren Boolean .
using System;
public class Example11
{
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
let raining = false
let busLate = true
printfn $"""It is raining: %s{if raining then "Yes" else "No"}"""
printfn $"""The bus is late: %s{if busLate then "Yes" else "No"}"""
// The example displays the following output:
// It is raining: No
// The bus is late: Yes
Für komplexere benutzerdefinierte Formatierungsvorgänge, einschließlich kultursensitiver Formatierungen, können Sie die String.Format(IFormatProvider, String, Object[]) Methode aufrufen und eine ICustomFormatter Implementierung bereitstellen. Im folgenden Beispiel werden die und IFormatProvider schnittstellen ICustomFormatter implementiert, um kultursensitive boolesche Zeichenfolgen für die Kulturen Englisch (USA), Französisch (Frankreich) und Russisch (Russland) bereitzustellen.
using System;
using System.Globalization;
public class Example4
{
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': верно
open System
open System.Globalization
type BooleanFormatter(culture) =
interface ICustomFormatter with
member this.Format(_, arg, formatProvider) =
if formatProvider <> this then null
else
match arg with
| :? bool as value ->
match culture.Name with
| "en-US" -> string arg
| "fr-FR" when value -> "vrai"
| "fr-FR" -> "faux"
| "ru-RU" when value -> "верно"
| "ru-RU" -> "неверно"
| _ -> string arg
| _ -> null
interface IFormatProvider with
member this.GetFormat(formatType) =
if formatType = typeof<ICustomFormatter> then this
else null
new() = BooleanFormatter CultureInfo.CurrentCulture
let cultureNames = [ ""; "en-US"; "fr-FR"; "ru-RU" ]
for cultureName in cultureNames do
let value = true
let culture = CultureInfo.CreateSpecificCulture cultureName
let formatter = BooleanFormatter culture
String.Format(formatter, "Value for '{0}': {1}", culture.Name, value)
|> printfn "%s"
// 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 Example4
Public Sub Main()
Dim cultureNames() As String = {"", "en-US", "fr-FR", "ru-RU"}
For Each cultureName In cultureNames
Dim value As Boolean = True
Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
Dim formatter As New BooleanFormatter(culture)
Dim result As String = String.Format(formatter, "Value for '{0}': {1}", culture.Name, value)
Console.WriteLine(result)
Next
End Sub
End Module
Public Class BooleanFormatter
Implements ICustomFormatter, IFormatProvider
Private culture As CultureInfo
Public Sub New()
Me.New(CultureInfo.CurrentCulture)
End Sub
Public Sub New(culture As CultureInfo)
Me.culture = culture
End Sub
Public Function GetFormat(formatType As Type) As Object _
Implements IFormatProvider.GetFormat
If formatType Is GetType(ICustomFormatter) Then
Return Me
Else
Return Nothing
End If
End Function
Public Function Format(fmt As String, arg As Object,
formatProvider As IFormatProvider) As String _
Implements ICustomFormatter.Format
' Exit if another format provider is used.
If Not formatProvider.Equals(Me) Then Return Nothing
' Exit if the type to be formatted is not a Boolean
If Not TypeOf arg Is Boolean Then Return Nothing
Dim value As Boolean = CBool(arg)
Select culture.Name
Case "en-US"
Return value.ToString()
Case "fr-FR"
If value Then
Return "vrai"
Else
Return "faux"
End If
Case "ru-RU"
If value Then
Return "верно"
Else
Return "неверно"
End If
Case Else
Return value.ToString()
End Select
End Function
End Class
' The example displays the following output:
' Value for '': True
' Value for 'en-US': True
' Value for 'fr-FR': vrai
' Value for 'ru-RU': верно
Optional können Sie Ressourcendateien verwenden, um kulturspezifische boolesche Zeichenfolgen zu definieren.
Konvertieren in und aus booleschen Werten
Die Boolean Struktur implementiert die IConvertible Schnittstelle. Daher können Sie die Convert Klasse verwenden, um Konvertierungen zwischen einem Boolean Wert und jedem anderen Grundtyp in .NET durchzuführen, oder Sie können die expliziten Implementierungen der Boolean Struktur aufrufen. Konvertierungen zwischen einem Boolean und den folgenden Typen werden jedoch nicht unterstützt, sodass die entsprechenden Konvertierungsmethoden eine InvalidCastException Ausnahme auslösen:
Konvertierung zwischen Boolean und Char (die Convert.ToBoolean(Char) Und Convert.ToChar(Boolean) Methoden).
Konvertierung zwischen Boolean und DateTime (die Convert.ToBoolean(DateTime) Und Convert.ToDateTime(Boolean) Methoden).
Alle Konvertierungen von integralen oder Gleitkommazahlen in boolesche Werte konvertieren Werte ungleich Null in true und Nullwerte in false. Im folgenden Beispiel wird dies veranschaulicht, indem ausgewählte Überladungen der Convert.ToBoolean Klasse aufgerufen werden.
using System;
public class Example2
{
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
open System
let byteValue = 12uy
printfn $"{Convert.ToBoolean byteValue}"
let byteValue2 = 0uy
printfn $"{Convert.ToBoolean byteValue2}"
let intValue = -16345
printfn $"{Convert.ToBoolean intValue}"
let longValue = 945L
printfn $"{Convert.ToBoolean longValue}"
let sbyteValue = -12y
printfn $"{Convert.ToBoolean sbyteValue}"
let dblValue = 0.0
printfn $"{Convert.ToBoolean dblValue}"
let sngValue = 0.0001f
printfn $"{Convert.ToBoolean sngValue}"
// The example displays the following output:
// True
// False
// True
// True
// True
// False
// True
Module Example2
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 = 0.0001
Console.WriteLine(Convert.ToBoolean(sngValue))
End Sub
End Module
' The example displays the following output:
' True
' False
' True
' True
' True
' False
' True
Beim Konvertieren von booleschen in numerische Werte werden die Konvertierungsmethoden der Convert Klasse in 1 und false 0 konvertierttrue. Visual Basic-Konvertierungsfunktionen werden jedoch entweder in 255 (für Konvertierungen in Byte Werte) oder -1 (für alle anderen numerischen Konvertierungen) konvertierttrue. Im folgenden Beispiel wird mithilfe einer Convert Methode in numerische Werte konvertierttrue, und im Fall des Visual Basic-Beispiels wird der eigene Konvertierungsoperator der Visual Basic-Sprache verwendet.
using System;
public class Example3
{
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
open System
let flag = true
let byteValue = Convert.ToByte flag
printfn $"{flag} -> {byteValue}"
let sbyteValue = Convert.ToSByte flag
printfn $"{flag} -> {sbyteValue}"
let dblValue = Convert.ToDouble flag
printfn $"{flag} -> {dblValue}"
let intValue = Convert.ToInt32(flag);
printfn $"{flag} -> {intValue}"
// The example displays the following output:
// True -> 1
// True -> 1
// True -> 1
// True -> 1
Module Example3
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 aus Boolean Zeichenfolgenwerten finden Sie im Abschnitt "Boolesche Werte formatieren". Informationen zu Konvertierungen von Zeichenfolgen in Boolean Werte finden Sie im Abschnitt " Boolesche Werte ".
Boolesche Werte analysieren
Die Boolean Struktur enthält zwei statische Analysemethoden Parse und TryParse, die eine Zeichenfolge in einen booleschen Wert konvertieren. Die angegebene Zeichenfolgendarstellung eines booleschen Werts wird durch die Groß-/Kleinschreibung Entsprechungen der Werte von definiert die TrueString und FalseString Felder, die "True" und "Falsch", bzw. Anders ausgedrückt: Die einzigen Zeichenfolgen, die erfolgreich analysiert werden, sind "True", "False", "true", "false", "false" oder ein gemischtes Äquivalent. Numerische Zeichenfolgen wie "0" oder "1" können nicht erfolgreich analysiert werden. Führende oder nachfolgende Leerzeichen werden beim Ausführen des Zeichenfolgenvergleichs nicht berücksichtigt.
Im folgenden Beispiel werden die und TryParse die Parse Methoden verwendet, um eine Reihe von Zeichenfolgen zu analysieren. Beachten Sie, dass nur die Entsprechungen von "True" und "False" erfolgreich analysiert werden können.
using System;
public class Example7
{
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'
open System
let values =
[ null; String.Empty; "True"; "False"
"true"; "false"; " true "
"TrUe"; "fAlSe"; "fa lse"; "0"
"1"; "-1"; "string" ]
// Parse strings using the Boolean.Parse method.
for value in values do
try
let flag = Boolean.Parse value
printfn $"'{value}' --> {flag}"
with
| :? ArgumentException ->
printfn "Cannot parse a null string."
| :? FormatException ->
printfn $"Cannot parse '{value}'."
printfn ""
// Parse strings using the Boolean.TryParse method.
for value in values do
match Boolean.TryParse value with
| true, flag ->
printfn $"'{value}' --> {flag}"
| false, _ ->
printfn $"Unable to parse '{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 Example7
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) Then
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 Zeichenfolgendarstellung einer Zahl in einen booleschen Wert zu konvertieren. "0" wird in false, und die Zeichenfolgendarstellung eines beliebigen Werts ungleich Null wird in konvertiert true. Wenn Sie in Visual Basic nicht programmieren, müssen Sie die numerische Zeichenfolge in eine Zahl konvertieren, bevor Sie sie in einen booleschen Wert konvertieren. Im folgenden Beispiel wird dies veranschaulicht, indem ein Array mit ganzen Zahlen in boolesche Werte konvertiert wird.
using System;
public class Example8
{
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
open System
let values = [ "09"; "12.6"; "0"; "-13 " ]
for value in values do
match Int32.TryParse value with
| true, number ->
// The method throws no exceptions.
let result = Convert.ToBoolean number
printfn $"Converted '{value}' to {result}"
| false, _ ->
printfn $"Unable to convert '{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 Example8
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
Boolesche Werte vergleichen
Da boolesche Werte entweder true oder false, gibt es wenig Grund, die CompareTo Methode explizit aufzurufen, was angibt, ob eine Instanz größer als, kleiner oder gleich einem angegebenen Wert ist. Wenn Sie normalerweise zwei boolesche Variablen vergleichen möchten, rufen Sie die Equals Methode auf, oder verwenden Sie den Gleichheitsoperator Ihrer Sprache.
Wenn Sie jedoch eine boolesche Variable mit dem literalen booleschen Wert true vergleichen möchten oder falsees nicht erforderlich ist, einen expliziten Vergleich durchzuführen, da das Ergebnis der Auswertung eines booleschen Werts dieser boolesche Wert ist. Die folgenden beiden Ausdrücke sind z. B. gleichwertig, die zweite ist jedoch kompakter. Beide Techniken bieten jedoch vergleichbare Leistung.
if (booleanValue == true) {
if booleanValue = true then
If booleanValue = True Then
if (booleanValue) {
if booleanValue then
If booleanValue Then
Arbeiten mit Booleans als Binäre Werte
Ein boolescher Wert belegt ein Byte Arbeitsspeicher, wie im folgenden Beispiel gezeigt. Das C#-Beispiel muss mit dem /unsafe Switch kompiliert werden.
using System;
public struct BoolStruct
{
public bool flag1;
public bool flag2;
public bool flag3;
public bool flag4;
public bool flag5;
}
public class Example9
{
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
#nowarn "9" "51"
open FSharp.NativeInterop
[<Struct>]
type BoolStruct =
val flag1: bool
val flag2: bool
val flag3: bool
val flag4: bool
val flag5: bool
let inline nint addr = NativePtr.toNativeInt addr
let mutable b = BoolStruct()
let addr = &&b
printfn $"Size of BoolStruct: {sizeof<BoolStruct>}"
printfn "Field offsets:"
printfn $" flag1: {nint &&b.flag1 - nint addr}"
printfn $" flag2: {nint &&b.flag2 - nint addr}"
printfn $" flag3: {nint &&b.flag3 - nint addr}"
printfn $" flag4: {nint &&b.flag4 - nint addr}"
printfn $" flag5: {nint &&b.flag5 - nint addr}"
// The example displays the following output:
// Size of BoolStruct: 5
// Field offsets:
// flag1: 0
// flag1: 1
// flag1: 2
// flag1: 3
// flag1: 4
Das Bit der niedrigen Reihenfolge des Bytes wird verwendet, um den Wert darzustellen. Ein Wert von 1 stellt truedar ; ein Wert von 0 steht für false.
Tipp
Sie können die System.Collections.Specialized.BitVector32 Struktur verwenden, um mit Booleschen Werten zu arbeiten.
Sie können einen booleschen Wert in die binäre Darstellung konvertieren, indem Sie die BitConverter.GetBytes(Boolean) Methode aufrufen. Die Methode gibt ein Bytearray mit einem einzelnen Element zurück. Um einen booleschen Wert aus seiner binären Darstellung wiederherzustellen, können Sie die BitConverter.ToBoolean(Byte[], Int32) Methode aufrufen.
Im folgenden Beispiel wird die BitConverter.GetBytes Methode aufgerufen, um einen booleschen Wert in die binäre Darstellung zu konvertieren, und zeigt die einzelnen Bits des Werts an und ruft dann die BitConverter.ToBoolean Methode auf, um den Wert aus der binären Darstellung wiederherzustellen.
using System;
public class Example1
{
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
open System
let getBinaryString (value: byte) =
let retValue = Convert.ToString(value, 2)
String('0', 8 - retValue.Length) + retValue
let flags = [ true; false ]
for flag in flags do
// Get binary representation of flag.
let value = BitConverter.GetBytes(flag)[0];
printfn $"Original value: {flag}"
printfn $"Binary value: {value} ({getBinaryString value})"
// Restore the flag from its binary representation.
let newFlag = BitConverter.ToBoolean([|value|], 0)
printfn $"Restored value: {newFlag}\n"
// 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 Example1
Public Sub Main()
Dim flags() As Boolean = {True, False}
For Each flag In flags
' Get binary representation of flag.
Dim value As Byte = BitConverter.GetBytes(flag)(0)
Console.WriteLine("Original value: {0}", flag)
Console.WriteLine("Binary value: {0} ({1})", value,
GetBinaryString(value))
' Restore the flag from its binary representation.
Dim newFlag As Boolean = BitConverter.ToBoolean({value}, 0)
Console.WriteLine("Restored value: {0}", flag)
Console.WriteLine()
Next
End Sub
Private Function GetBinaryString(value As Byte) As String
Dim retVal As String = Convert.ToString(value, 2)
Return New String("0"c, 8 - retVal.Length) + retVal
End Function
End Module
' The example displays the following output:
' Original value: True
' Binary value: 1 (00000001)
' Restored value: True
'
' Original value: False
' Binary value: 0 (00000000)
' Restored value: False
Ausführen von Vorgängen mit booleschen Werten
In diesem Abschnitt wird veranschaulicht, wie boolesche Werte in Apps verwendet werden. Im ersten Abschnitt wird die Verwendung als Kennzeichnung erläutert. Die zweite veranschaulicht die Verwendung für arithmetische Vorgänge.
Boolesche Werte als Kennzeichnungen
Boolesche Variablen werden am häufigsten als Kennzeichen verwendet, um das Vorhandensein oder Fehlen einer Bedingung zu signalisieren. Beispielsweise ist der letzte Parameter in der String.Compare(String, String, Boolean) Methode ein Flag, das angibt, ignoreCaseob bei dem Vergleich von zwei Zeichenfolgen die Groß-/Kleinschreibung beachtet wird (ignoreCase ist true) oder groß-/kleinschreibung (ignoreCase ist false). Der Wert der Kennzeichnung kann dann in einer bedingungsbedingten Anweisung ausgewertet werden.
Im folgenden Beispiel wird eine einfache Konsolen-App verwendet, um die Verwendung boolescher Variablen als Flags zu veranschaulichen. Die App akzeptiert Befehlszeilenparameter, mit denen die Ausgabe an eine angegebene Datei umgeleitet werden kann (schalter /f ), und die es ermöglichen, die Ausgabe sowohl an eine angegebene Datei als auch an die Konsole (den /b Schalter) zu senden. Die App definiert ein Flag, das angibt isRedirected , ob die Ausgabe an eine Datei gesendet werden soll, und ein Flag, isBoth das angibt, dass die Ausgabe an die Konsole gesendet werden soll. Im F#-Beispiel wird eine rekursive Funktion verwendet, um die Argumente zu analysieren.
using System;
using System.IO;
using System.Threading;
public class Example5
{
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");
}
}
open System
open System.IO
open System.Threading
let showSyntax errMsg =
printfn $"{errMsg}\n\nSyntax: Example [[/f <filename> [/b]]\n"
let mutable isRedirected = false
let mutable isBoth = false
let mutable fileName = ""
let rec parse = function
| [] -> ()
| "-b" :: rest
| "/b" :: rest ->
isBoth <- true
// Parse remaining arguments.
parse rest
| "-f" :: file :: rest
| "/f" :: file :: rest ->
isRedirected <- true
fileName <- file
// Parse remaining arguments.
parse rest
| "-f" :: []
| "/f" :: [] ->
isRedirected <- true
// No more arguments to parse.
| x -> showSyntax $"The {x} switch is not supported"
Environment.GetCommandLineArgs()[1..]
|> List.ofArray
|> parse
// If isBoth is True, isRedirected must be True.
if isBoth && not isRedirected then
showSyntax "The /f switch must be used if /b is used."
// If isRedirected is True, a fileName must be specified.
elif fileName = "" && isRedirected then
showSyntax "The /f switch must be followed by a filename."
else
use mutable sw = null
// Handle output.
let writeLine =
if isRedirected then
sw <- new StreamWriter(fileName)
if isBoth then
fun text ->
printfn "%s" text
sw.WriteLine text
else sw.WriteLine
else printfn "%s"
writeLine $"Application began at {DateTime.Now}"
Thread.Sleep 5000
writeLine $"Application ended normally at {DateTime.Now}"
Imports System.IO
Imports System.Threading
Module Example5
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
Boolescher und arithmetische Vorgänge
Ein boolescher Wert wird manchmal verwendet, um das Vorhandensein einer Bedingung anzugeben, die eine mathematische Berechnung auslöst. Beispielsweise kann eine hasShippingCharge Variable als Kennzeichnung dienen, um anzugeben, ob Versandkosten zu einem Rechnungsbetrag hinzugefügt werden sollen.
Da ein Vorgang mit einem false Wert keine Auswirkungen auf das Ergebnis eines Vorgangs hat, ist es nicht erforderlich, den booleschen Wert in einen integralen Wert zu konvertieren, der in der mathematischen Operation verwendet werden soll. Stattdessen können Sie bedingte Logik verwenden.
Im folgenden Beispiel wird ein Betrag berechnet, der aus einem Teilergebnis, einer Versandkosten und einer optionalen Servicegebühr besteht. Die hasServiceCharge Variable bestimmt, ob die Servicegebühr angewendet wird. Anstatt in einen numerischen Wert zu konvertieren hasServiceCharge und ihn mit dem Betrag der Dienstgebühr zu multiplizieren, verwendet das Beispiel bedingte Logik, um den Betrag der Dienstgebühr hinzuzufügen, falls zutreffend.
using System;
public class Example6
{
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.
let hasServiceCharges = [ true; false ]
let subtotal = 120.62M
let shippingCharge = 2.50M
let serviceCharge = 5.00M
for hasServiceCharge in hasServiceCharges do
let total =
subtotal + shippingCharge + if hasServiceCharge then serviceCharge else 0M
printfn $"hasServiceCharge = {hasServiceCharge}: The total is {total:C2}."
// The example displays output like the following:
// hasServiceCharge = True: The total is $128.12.
// hasServiceCharge = False: The total is $123.12.
Module Example6
Public Sub Main()
Dim hasServiceCharges() As Boolean = {True, False}
Dim subtotal As Decimal = 120.62D
Dim shippingCharge As Decimal = 2.5D
Dim serviceCharge As Decimal = 5D
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.
Boolescher Und Interop
Während das Marshallen von Basisdatentypen bei COM im Allgemeinen einfach ist, ist der Boolean Datentyp eine Ausnahme. Sie können das MarshalAsAttribute Attribut auf eine der folgenden Darstellungen anwenden, um den Boolean Typ zu marshallen:
| Enumerationstyp | Nicht verwaltetes Format |
|---|---|
| UnmanagedType.Bool | Ein ganzzahliger 4-Byte-Wert, wobei ein beliebiger Wert ungleich Null und true 0 darstellt false. Dies ist das Standardformat eines Boolean Felds in einer Struktur und eines Boolean Parameters in Plattformaufrufen. |
| UnmanagedType.U1 | Ein ganzzahliger 1-Byte-Wert, wobei die 1 darstellt true und 0 darstellt false. |
| UnmanagedType.VariantBool | Ein ganzzahliger 2-Byte-Wert, wobei -1 steht true und 0 darstellt false. Dies ist das Standardformat eines Boolean Parameters in COM-Interoperabilitätsaufrufen. |
