System.Boolean, struktura
Ten artykuł zawiera dodatkowe uwagi dotyczące dokumentacji referencyjnej dla tego interfejsu API.
Wystąpienie Boolean może mieć jedną z dwóch wartości: true lub false.
Struktura Boolean udostępnia metody, które obsługują następujące zadania:
- Konwertowanie wartości logicznych na ciągi: ToString
- Analizowanie ciągów w celu przekonwertowania ich na wartości logiczne: Parse i TryParse
- Porównywanie wartości: CompareTo i Equals
W tym artykule opisano te zadania i inne szczegóły użycia.
Formatowanie wartości logicznych
Reprezentacja ciągu elementu Boolean to "True" dla true wartości lub "Fałsz" dla false wartości. Reprezentacja Boolean ciągu wartości jest definiowana przez pola i FalseString tylko do TrueString odczytu.
Metoda służy do konwertowania ToString wartości logicznych na ciągi. Struktura logiczna obejmuje dwa ToString przeciążenia: metodę bez ToString() parametrów i ToString(IFormatProvider) metodę, która zawiera parametr, który kontroluje formatowanie. Jednak ponieważ ten parametr jest ignorowany, dwa przeciążenia generują identyczne ciągi. Metoda ToString(IFormatProvider) nie obsługuje formatowania wrażliwego na kulturę.
Poniższy przykład ilustruje formatowanie za pomocą ToString metody . Należy pamiętać, że przykłady języka C# i VB używają funkcji formatowania złożonego, podczas gdy w przykładzie języka F# jest używana interpolacja ciągów. W obu przypadkach metoda jest wywoływana ToString niejawnie.
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
Boolean Ponieważ struktura może mieć tylko dwie wartości, łatwo jest dodać niestandardowe formatowanie. W przypadku prostego formatowania niestandardowego, w którym inne literały ciągów są zastępowane wartościami "True" i "False", można użyć dowolnej funkcji oceny warunkowej obsługiwanej przez język, takiej jak operator warunkowy w języku C# lub operator If w Visual Basic. W poniższym przykładzie użyto tej techniki do formatowania Boolean wartości jako "Tak" i "Nie", a nie "True" i "False".
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
W przypadku bardziej złożonych niestandardowych operacji formatowania, w tym formatowania wrażliwego na kulturę, można wywołać metodę String.Format(IFormatProvider, String, Object[]) i zapewnić implementację ICustomFormatter . Poniższy przykład implementuje ICustomFormatter interfejsy i IFormatProvider w celu zapewnienia ciągów logicznych wrażliwych na kulturę dla angielskich (Stany Zjednoczone), francuskich (Francja) i rosyjskich (Rosja).
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': верно
Opcjonalnie możesz użyć plików zasobów do zdefiniowania ciągów logicznych specyficznych dla kultury.
Konwertowanie na wartości logiczne i z wartości logicznych
Struktura Boolean implementuje IConvertible interfejs. W związku z tym można użyć Convert klasy do przeprowadzania konwersji między wartością Boolean a dowolnym innym typem pierwotnym na platformie .NET lub wywołać Boolean jawne implementacje struktury. Jednak konwersje między a Boolean następującymi typami nie są obsługiwane, więc odpowiednie metody konwersji zgłaszają InvalidCastException wyjątek:
Konwersja między Boolean i Char (metody Convert.ToBoolean(Char) i Convert.ToChar(Boolean) ).
Konwersja między Boolean i DateTime (metody Convert.ToBoolean(DateTime) i Convert.ToDateTime(Boolean) ).
Wszystkie konwersje z liczb całkowitych lub zmiennoprzecinkowych na wartości logiczne konwertują wartości niezerowe na i zero na truefalsewartość . Poniższy przykład ilustruje to przez wywołanie wybranych przeciążeń Convert.ToBoolean klasy.
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
Podczas konwertowania z wartości logicznych na wartości liczbowe metody Convert konwersji klasy są konwertowane true na wartość 1 i false 0. Jednak funkcje konwersji języka Visual Basic konwertują true na wartość 255 (w przypadku konwersji na Byte wartości) lub -1 (dla wszystkich innych konwersji liczbowych). Poniższy przykład konwertuje true na wartości liczbowe przy użyciu Convert metody , a w przypadku przykładu języka Visual Basic przy użyciu własnego operatora konwersji języka Visual Basic.
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)
Aby uzyskać informacje na temat konwersji z Boolean wartości ciągów, zobacz sekcję Formatowanie wartości logicznych. Aby uzyskać konwersje z ciągów na Boolean wartości, zobacz sekcję Analizowanie wartości logicznych.
Analizowanie wartości logicznych
Struktura Boolean zawiera dwie statyczne metody analizowania i ParseTryParse, które konwertują ciąg na wartość logiczną. Reprezentacja ciągu wartości logicznej jest definiowana przez odpowiedniki bez uwzględniania wielkości liter wartości TrueString pól i FalseString , które są odpowiednio wartościami "True" i "False". Innymi słowy, jedynymi ciągami, które pomyślnie analizują, są "True", "False", "true", "false" lub niektórymi odpowiednikami mieszanych liter. Nie można pomyślnie przeanalizować ciągów liczbowych, takich jak "0" lub "1". Znaki wiodące lub końcowe białych znaków nie są brane pod uwagę podczas porównywania ciągów.
W poniższym przykładzie użyto Parse metod i TryParse do analizowania wielu ciągów. Należy pamiętać, że tylko odpowiedniki wielkości liter "True" i "False" można pomyślnie przeanalizować.
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'
Jeśli programujesz w języku Visual Basic, możesz użyć CBool funkcji , aby przekonwertować reprezentację ciągu liczby na wartość logiczną. Wyrażenie "0" jest konwertowane na falsewartość , a reprezentacja ciągu dowolnej wartości innej niż zero jest konwertowana na truewartość . Jeśli nie programujesz w Visual Basic, musisz przekonwertować ciąg liczbowy na liczbę przed przekonwertowaniem go na wartość logiczną. Poniższy przykład ilustruje to przez przekonwertowanie tablicy liczb całkowitych na wartości logiczne.
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
Porównywanie wartości logicznych
Ponieważ wartości logiczne są albo true lub false, nie ma powodu, aby jawnie wywołać metodę CompareTo , która wskazuje, czy wystąpienie jest większe niż, mniejsze lub równe określonej wartości. Zazwyczaj, aby porównać dwie zmienne logiczne, należy wywołać metodę Equals lub użyć operatora równości języka.
Jeśli jednak chcesz porównać zmienną logiczną z wartością true logiczną literału lub false, nie jest konieczne jawne porównanie, ponieważ wynikiem oceny wartości logicznej jest wartość logiczna. Na przykład następujące dwa wyrażenia są równoważne, ale drugi jest bardziej kompaktowy. Jednak obie techniki oferują porównywalną wydajność.
if (booleanValue == true) {
if booleanValue = true then
If booleanValue = True Then
if (booleanValue) {
if booleanValue then
If booleanValue Then
Praca z wartościami logicznymi jako wartościami binarnymi
Wartość logiczna zajmuje jeden bajt pamięci, jak pokazano w poniższym przykładzie. Przykład języka C# należy skompilować za pomocą przełącznika /unsafe .
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
Bit o niskiej kolejności bajtu jest używany do reprezentowania jego wartości. Wartość 1 reprezentuje truewartość ; wartość 0 reprezentuje falsewartość .
Napiwek
Możesz użyć System.Collections.Specialized.BitVector32 struktury do pracy z zestawami wartości logicznych.
Wartość logiczną można przekonwertować na jej reprezentację binarną, wywołując metodę BitConverter.GetBytes(Boolean) . Metoda zwraca tablicę bajtów z pojedynczym elementem. Aby przywrócić wartość logiczną z jej reprezentacji binarnej, możesz wywołać metodę BitConverter.ToBoolean(Byte[], Int32) .
W poniższym przykładzie BitConverter.GetBytes metoda wywołuje metodę , aby przekonwertować wartość logiczną na jej reprezentację binarną i wyświetlić poszczególne bity wartości, a następnie wywołuje BitConverter.ToBoolean metodę w celu przywrócenia wartości z jej reprezentacji binarnej.
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
Wykonywanie operacji przy użyciu wartości logicznych
W tej sekcji pokazano, jak wartości logiczne są używane w aplikacjach. W pierwszej sekcji omówiono jej użycie jako flagę. Drugi ilustruje użycie operacji arytmetycznych.
Wartości logiczne jako flagi
Zmienne logiczne są najczęściej używane jako flagi, aby zasygnalizować obecność lub brak pewnego warunku. Na przykład w metodzie String.Compare(String, String, Boolean) parametr końcowy , jest flagą wskazującą, ignoreCaseczy porównanie dwóch ciągów jest bez uwzględniania wielkości liter (ignoreCase jest ) lub uwzględnia wielkość liter (ignoreCase to truefalse). Wartość flagi można następnie ocenić w instrukcji warunkowej.
W poniższym przykładzie użyto prostej aplikacji konsolowej, aby zilustrować użycie zmiennych logicznych jako flag. Aplikacja akceptuje parametry wiersza polecenia, które umożliwiają przekierowywanie danych wyjściowych do określonego pliku ( /f przełącznika) i które umożliwiają wysyłanie danych wyjściowych zarówno do określonego pliku, jak i do konsoli (przełącznika /b ). Aplikacja definiuje flagę o nazwie isRedirected , aby wskazać, czy dane wyjściowe mają być wysyłane do pliku, a flaga o nazwie isBoth wskazująca, że dane wyjściowe powinny być wysyłane do konsoli. W przykładzie języka F# funkcja rekursywna analizuje argumenty.
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
Operacje logiczne i arytmetyczne
Wartość logiczna jest czasami używana do wskazywania obecności warunku, który wyzwala obliczenie matematyczne. Na przykład zmienna może służyć jako flaga hasShippingCharge wskazująca, czy dodać opłaty wysyłkowe do kwoty faktury.
Ponieważ operacja z wartością false nie ma wpływu na wynik operacji, nie jest konieczne przekonwertowanie wartości logicznej na wartość całkowitą do użycia w operacji matematycznej. Zamiast tego można użyć logiki warunkowej.
Poniższy przykład oblicza kwotę, która składa się z sumy częściowej, opłaty za wysyłkę i opcjonalnej opłaty za usługę. Zmienna hasServiceCharge określa, czy opłata za usługę jest stosowana. Zamiast konwertować hasServiceCharge na wartość liczbową i mnożyć ją przez kwotę opłaty za usługę, w przykładzie użyto logiki warunkowej w celu dodania kwoty opłaty za usługę, jeśli ma to zastosowanie.
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.
Wartości logiczne i międzyoperacyjne
Podczas gdy przeprowadzanie marshalingu podstawowych typów danych do modelu COM jest ogólnie proste, Boolean typ danych jest wyjątkiem. Atrybut można zastosować MarshalAsAttribute do marshalingu Boolean typu do dowolnej z następujących reprezentacji:
| Typ wyliczenia | Format niezarządzany |
|---|---|
| UnmanagedType.Bool | 4-bajtowa wartość całkowita, gdzie każda wartość niezerowa reprezentuje true wartość i 0 reprezentuje falsewartość . Jest to domyślny format Boolean pola w strukturze i parametru Boolean w wywołaniach wywołań platformy. |
| UnmanagedType.U1 | 1-bajtowa wartość całkowita, gdzie wartość 1 reprezentuje true i 0 reprezentuje falsewartość . |
| UnmanagedType.VariantBool | 2-bajtowa wartość całkowita, gdzie -1 reprezentuje true i 0 reprezentuje falsewartość . Jest to domyślny format parametru Boolean w wywołaniach międzyoperajności MODELU COM. |
Opinia
Dostępne już wkrótce: W 2024 r. będziemy stopniowo wycofywać zgłoszenia z serwisu GitHub jako mechanizm przesyłania opinii na temat zawartości i zastępować go nowym systemem opinii. Aby uzyskać więcej informacji, sprawdź: https://aka.ms/ContentUserFeedback.
Prześlij i wyświetl opinię dla