Boolean Structure
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Représente une valeur booléenne (true ou false).
public value class bool : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>public value class bool : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>, IParsable<bool>, ISpanParsable<bool>public value class bool : IComparable, IConvertiblepublic value class bool : IComparable, IComparable<bool>, IEquatable<bool>public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>public readonly struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>public readonly struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>, IParsable<bool>, ISpanParsable<bool>[System.Serializable]
public struct Boolean : IComparable, IConvertible[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>public struct Boolean : IComparable, IComparable<bool>, IEquatable<bool>type bool = struct
interface IConvertibletype bool = struct
interface IConvertible
interface IParsable<bool>
interface ISpanParsable<bool>[<System.Serializable>]
type bool = struct
interface IConvertible[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type bool = struct
interface IConvertibletype bool = structPublic Structure Boolean
Implements IComparable, IComparable(Of Boolean), IConvertible, IEquatable(Of Boolean)Public Structure Boolean
Implements IComparable, IComparable(Of Boolean), IConvertible, IEquatable(Of Boolean), IParsable(Of Boolean), ISpanParsable(Of Boolean)Public Structure Boolean
Implements IComparable, IConvertiblePublic Structure Boolean
Implements IComparable, IComparable(Of Boolean), IEquatable(Of Boolean)- Héritage
- Attributs
- Implémente
Remarques
Une Boolean instance peut avoir l’une des deux valeurs : true ou false.
La Boolean structure fournit des méthodes qui prennent en charge les tâches suivantes :
Conversion de valeurs booléennes en chaînes : ToString
Analyse des chaînes pour les convertir en valeurs booléennes : Parse et TryParse
Les sections suivantes expliquent ces tâches et d’autres détails d’utilisation :
- Mettre en forme des valeurs booléennes
- Convertir vers et à partir de valeurs booléennes
- Analyser les valeurs booléennes
- Comparer les valeurs booléennes
- Utiliser des booléens en tant que valeurs binaires
- Effectuer des opérations avec des valeurs booléennes
- Booleans et interopérabilité
Mettre en forme des valeurs booléennes
La représentation sous forme de chaîne d’un Boolean est « True » pour une true valeur ou « False » pour une false valeur. La représentation sous forme de chaîne d’une Boolean valeur est définie par les champs et FalseString en lecture seuleTrueString.
Vous utilisez la ToString méthode pour convertir des valeurs booléennes en chaînes. La structure booléenne comprend deux ToString surcharges : la méthode sans ToString() paramètre et la ToString(IFormatProvider) méthode, qui comprend un paramètre qui contrôle la mise en forme. Toutefois, étant donné que ce paramètre est ignoré, les deux surcharges produisent des chaînes identiques. La ToString(IFormatProvider) méthode ne prend pas en charge la mise en forme sensible à la culture.
L’exemple suivant illustre la mise en forme avec la ToString méthode . Notez que les exemples C# et VB utilisent la fonctionnalité de mise en forme composite , tandis que l’exemple F# utilise l’interpolation de chaîne. Dans les deux cas, la ToString méthode est appelée implicitement.
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
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 Example
Public Sub Main()
Dim raining As Boolean = False
Dim busLate As Boolean = True
Console.WriteLine("It is raining: {0}", raining)
Console.WriteLine("The bus is late: {0}", busLate)
End Sub
End Module
' The example displays the following output:
' It is raining: False
' The bus is late: True
Étant donné que la Boolean structure ne peut avoir que deux valeurs, il est facile d’ajouter une mise en forme personnalisée. Pour une mise en forme personnalisée simple dans laquelle d’autres littéraux de chaîne sont remplacés par « True » et « False », vous pouvez utiliser n’importe quelle fonctionnalité d’évaluation conditionnelle prise en charge par votre langage, comme l’opérateur conditionnel en C# ou l’opérateur If en Visual Basic. L’exemple suivant utilise cette technique pour mettre en forme Boolean les valeurs « Oui » et « Non » au lieu de « True » et « False ».
using System;
public class Example
{
public static void Main()
{
bool raining = false;
bool busLate = true;
Console.WriteLine("It is raining: {0}",
raining ? "Yes" : "No");
Console.WriteLine("The bus is late: {0}",
busLate ? "Yes" : "No" );
}
}
// The example displays the following output:
// It is raining: No
// The bus is late: Yes
Module Example
Public Sub Main()
Dim raining As Boolean = False
Dim busLate As Boolean = True
Console.WriteLine("It is raining: {0}",
If(raining, "Yes", "No"))
Console.WriteLine("The bus is late: {0}",
If(busLate, "Yes", "No"))
End Sub
End Module
' The example displays the following output:
' It is raining: No
' The bus is late: Yes
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
Pour les opérations de mise en forme personnalisée plus complexes, y compris la mise en forme sensible à la culture, vous pouvez appeler la String.Format(IFormatProvider, String, Object[]) méthode et fournir une ICustomFormatter implémentation. L’exemple suivant implémente les ICustomFormatter interfaces et IFormatProvider pour fournir des chaînes booléennes sensibles à la culture pour les cultures anglaise (États-Unis), Français (France) et russe (Russie).
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': верно
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 Example
Public Sub Main()
Dim cultureNames() As String = { "", "en-US", "fr-FR", "ru-RU" }
For Each cultureName In cultureNames
Dim value As Boolean = True
Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
Dim formatter As New BooleanFormatter(culture)
Dim result As String = String.Format(formatter, "Value for '{0}': {1}", culture.Name, value)
Console.WriteLine(result)
Next
End Sub
End Module
Public Class BooleanFormatter
Implements ICustomFormatter, IFormatProvider
Private culture As CultureInfo
Public Sub New()
Me.New(CultureInfo.CurrentCulture)
End Sub
Public Sub New(culture As CultureInfo)
Me.culture = culture
End Sub
Public Function GetFormat(formatType As Type) As Object _
Implements IFormatProvider.GetFormat
If formatType Is GetType(ICustomFormatter) Then
Return Me
Else
Return Nothing
End If
End Function
Public Function Format(fmt As String, arg As Object,
formatProvider As IFormatProvider) As String _
Implements ICustomFormatter.Format
' Exit if another format provider is used.
If Not formatProvider.Equals(Me) Then Return Nothing
' Exit if the type to be formatted is not a Boolean
If Not TypeOf arg Is Boolean Then Return Nothing
Dim value As Boolean = CBool(arg)
Select culture.Name
Case "en-US"
Return value.ToString()
Case "fr-FR"
If value Then
Return "vrai"
Else
Return "faux"
End If
Case "ru-RU"
If value Then
Return "верно"
Else
Return "неверно"
End If
Case Else
Return value.ToString()
End Select
End Function
End Class
' The example displays the following output:
' Value for '': True
' Value for 'en-US': True
' Value for 'fr-FR': vrai
' Value for 'ru-RU': верно
Si vous le souhaitez, vous pouvez utiliser des fichiers de ressources pour définir des chaînes booléennes spécifiques à la culture.
Convertir vers et à partir de valeurs booléennes
La Boolean structure implémente l’interface IConvertible . Par conséquent, vous pouvez utiliser la Convert classe pour effectuer des conversions entre une Boolean valeur et tout autre type primitif dans .NET, ou vous pouvez appeler les implémentations explicites de la Boolean structure. Toutefois, les conversions entre les types suivants Boolean et n’étant pas prises en charge, les méthodes de conversion correspondantes lèvent une InvalidCastException exception :
Conversion entre Boolean et Char (les Convert.ToBoolean(Char) méthodes et Convert.ToChar(Boolean) )
Conversion entre Boolean et DateTime (les Convert.ToBoolean(DateTime) méthodes et Convert.ToDateTime(Boolean) )
Toutes les conversions de nombres intégraux ou à virgule flottante en valeurs booléennes convertissent des valeurs non nulles en true et des valeurs nulles en false. L’exemple suivant illustre cela en appelant les surcharges sélectionnées de la Convert.ToBoolean classe.
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
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 Example
Public Sub Main()
Dim byteValue As Byte = 12
Console.WriteLine(Convert.ToBoolean(byteValue))
Dim byteValue2 As Byte = 0
Console.WriteLine(Convert.ToBoolean(byteValue2))
Dim intValue As Integer = -16345
Console.WriteLine(Convert.ToBoolean(intValue))
Dim longValue As Long = 945
Console.WriteLine(Convert.ToBoolean(longValue))
Dim sbyteValue As SByte = -12
Console.WriteLine(Convert.ToBoolean(sbyteValue))
Dim dblValue As Double = 0
Console.WriteLine(Convert.ToBoolean(dblValue))
Dim sngValue As Single = .0001
Console.WriteLine(Convert.ToBoolean(sngValue))
End Sub
End Module
' The example displays the following output:
' True
' False
' True
' True
' True
' False
' True
Lors de la conversion de booléen en valeurs numériques, les méthodes de conversion de la Convert classe sont converties en true 1 et false en 0. Toutefois, les fonctions de conversion Visual Basic sont converties en true 255 (pour les conversions en Byte valeurs) ou -1 (pour toutes les autres conversions numériques). L’exemple suivant convertit true en valeurs numériques à l’aide d’une Convert méthode et, dans le cas de l’exemple Visual Basic, en utilisant le propre opérateur de conversion du langage Visual Basic.
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
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 Example
Public Sub Main()
Dim flag As Boolean = true
Dim byteValue As Byte
byteValue = Convert.ToByte(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, byteValue,
byteValue.GetType().Name)
byteValue = CByte(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, byteValue,
byteValue.GetType().Name)
Dim sbyteValue As SByte
sbyteValue = Convert.ToSByte(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue,
sbyteValue.GetType().Name)
sbyteValue = CSByte(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue,
sbyteValue.GetType().Name)
Dim dblValue As Double
dblValue = Convert.ToDouble(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, dblValue,
dblValue.GetType().Name)
dblValue = CDbl(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, dblValue,
dblValue.GetType().Name)
Dim intValue As Integer
intValue = Convert.ToInt32(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, intValue,
intValue.GetType().Name)
intValue = CInt(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, intValue,
intValue.GetType().Name)
End Sub
End Module
' The example displays the following output:
' True -> 1 (Byte)
' True -> 255 (Byte)
' True -> 1 (SByte)
' True -> -1 (SByte)
' True -> 1 (Double)
' True -> -1 (Double)
' True -> 1 (Int32)
' True -> -1 (Int32)
Pour connaître les conversions de en valeurs de Boolean chaîne, consultez la section Mise en forme des valeurs booléennes . Pour connaître les conversions de chaînes en Boolean valeurs, consultez la section Analyse des valeurs booléennes .
Analyser les valeurs booléennes
La Boolean structure comprend deux méthodes d’analyse statique, Parse et TryParse, qui convertissent une chaîne en valeur booléenne. La représentation sous forme de chaîne d’une valeur booléenne est définie par les équivalents qui ne respectent pas la casse des valeurs des TrueString champs et FalseString , respectivement, « True » et « False ». En d’autres termes, les seules chaînes qui analysent correctement sont « True », « False », « true », « false », « false » ou un équivalent en cas mixte. Vous ne pouvez pas analyser correctement des chaînes numériques telles que « 0 » ou « 1 ». Les espaces blancs de début ou de fin ne sont pas pris en compte lors de la comparaison de chaînes.
L’exemple suivant utilise les Parse méthodes et TryParse pour analyser un certain nombre de chaînes. Notez que seuls les équivalents non respectant la casse de « True » et « False » peuvent être analysés avec succès.
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'
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 Example
Public Sub Main()
Dim values() As String = { Nothing, String.Empty, "True", "False",
"true", "false", " true ",
"TrUe", "fAlSe", "fa lse", "0",
"1", "-1", "string" }
' Parse strings using the Boolean.Parse method.
For Each value In values
Try
Dim flag As Boolean = Boolean.Parse(value)
Console.WriteLine("'{0}' --> {1}", value, flag)
Catch e As ArgumentException
Console.WriteLine("Cannot parse a null string.")
Catch e As FormatException
Console.WriteLine("Cannot parse '{0}'.", value)
End Try
Next
Console.WriteLine()
' Parse strings using the Boolean.TryParse method.
For Each value In values
Dim flag As Boolean = False
If Boolean.TryParse(value, flag)
Console.WriteLine("'{0}' --> {1}", value, flag)
Else
Console.WriteLine("Cannot parse '{0}'.", value)
End If
Next
End Sub
End Module
' The example displays the following output:
' Cannot parse a null string.
' Cannot parse ''.
' 'True' --> True
' 'False' --> False
' 'true' --> True
' 'false' --> False
' ' true ' --> True
' 'TrUe' --> True
' 'fAlSe' --> False
' Cannot parse 'fa lse'.
' Cannot parse '0'.
' Cannot parse '1'.
' Cannot parse '-1'.
' Cannot parse 'string'.
'
' Unable to parse ''
' Unable to parse ''
' 'True' --> True
' 'False' --> False
' 'true' --> True
' 'false' --> False
' ' true ' --> True
' 'TrUe' --> True
' 'fAlSe' --> False
' Cannot parse 'fa lse'.
' Unable to parse '0'
' Unable to parse '1'
' Unable to parse '-1'
' Unable to parse 'string'
Si vous programmez en Visual Basic, vous pouvez utiliser la CBool fonction pour convertir la représentation sous forme de chaîne d’un nombre en valeur booléenne. « 0 » est converti falseen , et la représentation sous forme de chaîne de toute valeur autre que zéro est convertie trueen . Si vous ne programmez pas en Visual Basic, vous devez convertir votre chaîne numérique en nombre avant de la convertir en booléen. L’exemple suivant illustre cela en convertissant un tableau d’entiers en valeurs booléennes.
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
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 Example
Public Sub Main()
Dim values() As String = { "09", "12.6", "0", "-13 " }
For Each value In values
Dim success, result As Boolean
Dim number As Integer
success = Int32.TryParse(value, number)
If success Then
' The method throws no exceptions.
result = Convert.ToBoolean(number)
Console.WriteLine("Converted '{0}' to {1}", value, result)
Else
Console.WriteLine("Unable to convert '{0}'", value)
End If
Next
End Sub
End Module
' The example displays the following output:
' Converted '09' to True
' Unable to convert '12.6'
' Converted '0' to False
' Converted '-13 ' to True
Comparer les valeurs booléennes
Étant donné que les valeurs booléennes sont true ou false, il existe peu de raisons d’appeler explicitement la CompareTo méthode, qui indique si une instance est supérieure, inférieure ou égale à une valeur spécifiée. En règle générale, pour comparer deux variables booléennes, vous appelez la méthode ou utilisez l’opérateur Equals d’égalité de votre langue.
Toutefois, lorsque vous souhaitez comparer une variable booléenne avec la valeur true booléenne littérale ou false, il n’est pas nécessaire d’effectuer une comparaison explicite, car le résultat de l’évaluation d’une valeur booléenne est cette valeur booléenne. Par exemple, les expressions
if (booleanValue == true) {
if booleanValue = true then
If booleanValue = True Then
et
if (booleanValue) {
if booleanValue then
If booleanValue Then
sont équivalents, mais la seconde est plus compacte. Toutefois, les deux techniques offrent des performances comparables.
Utiliser des valeurs booléennes en tant que valeurs binaires
Une valeur booléenne occupe un octet de mémoire, comme le montre l’exemple C# ou F# suivant. L’exemple C# doit être compilé avec le /unsafe commutateur.
using System;
public struct BoolStruct
{
public bool flag1;
public bool flag2;
public bool flag3;
public bool flag4;
public bool flag5;
}
public class Example
{
public static void Main()
{
unsafe {
BoolStruct b = new BoolStruct();
bool* addr = (bool*) &b;
Console.WriteLine("Size of BoolStruct: {0}", sizeof(BoolStruct));
Console.WriteLine("Field offsets:");
Console.WriteLine(" flag1: {0}", (bool*) &b.flag1 - addr);
Console.WriteLine(" flag1: {0}", (bool*) &b.flag2 - addr);
Console.WriteLine(" flag1: {0}", (bool*) &b.flag3 - addr);
Console.WriteLine(" flag1: {0}", (bool*) &b.flag4 - addr);
Console.WriteLine(" flag1: {0}", (bool*) &b.flag5 - addr);
}
}
}
// The example displays the following output:
// Size of BoolStruct: 5
// Field offsets:
// flag1: 0
// flag1: 1
// flag1: 2
// flag1: 3
// flag1: 4
#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
Le bit d’ordre faible de l’octet est utilisé pour représenter sa valeur. La valeur 1 représente true; la valeur 0 représente false.
Conseil
Vous pouvez utiliser la System.Collections.Specialized.BitVector32 structure pour travailler avec des ensembles de valeurs booléennes.
Vous pouvez convertir une valeur booléenne en sa représentation binaire en appelant la BitConverter.GetBytes(Boolean) méthode . La méthode retourne un tableau d’octets avec un seul élément. Pour restaurer une valeur booléenne à partir de sa représentation binaire, vous pouvez appeler la BitConverter.ToBoolean(Byte[], Int32) méthode .
L’exemple suivant appelle la BitConverter.GetBytes méthode pour convertir une valeur booléenne en sa représentation binaire et affiche les bits individuels de la valeur, puis appelle la BitConverter.ToBoolean méthode pour restaurer la valeur à partir de sa représentation binaire.
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
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 Example
Public Sub Main()
Dim flags() As Boolean = { True, False }
For Each flag In flags
' Get binary representation of flag.
Dim value As Byte = BitConverter.GetBytes(flag)(0)
Console.WriteLine("Original value: {0}", flag)
Console.WriteLine("Binary value: {0} ({1})", value,
GetBinaryString(value))
' Restore the flag from its binary representation.
Dim newFlag As Boolean = BitConverter.ToBoolean( { value }, 0)
Console.WriteLine("Restored value: {0}", flag)
Console.WriteLine()
Next
End Sub
Private Function GetBinaryString(value As Byte) As String
Dim retVal As String = Convert.ToString(value, 2)
Return New String("0"c, 8 - retVal.Length) + retVal
End Function
End Module
' The example displays the following output:
' Original value: True
' Binary value: 1 (00000001)
' Restored value: True
'
' Original value: False
' Binary value: 0 (00000000)
' Restored value: False
Effectuer des opérations avec des valeurs booléennes
Cette section illustre comment les valeurs booléennes sont utilisées dans les applications. La première section décrit son utilisation en tant qu’indicateur. Le second illustre son utilisation pour les opérations arithmétiques.
Valeurs booléennes en tant qu’indicateurs
Les variables booléennes sont le plus souvent utilisées comme indicateurs, pour signaler la présence ou l’absence d’une condition. Par exemple, dans la String.Compare(String, String, Boolean) méthode , le paramètre final, ignoreCase, est un indicateur qui indique si la comparaison de deux chaînes ne respecte pas la casse (ignoreCase est true) ou respecte la casse (ignoreCase est false). La valeur de l’indicateur peut ensuite être évaluée dans une instruction conditionnelle.
L’exemple suivant utilise une application console simple pour illustrer l’utilisation de variables booléennes en tant qu’indicateurs. L’application accepte les paramètres de ligne de commande qui permettent de rediriger la sortie vers un fichier spécifié (le /f commutateur) et qui permettent d’envoyer la sortie à un fichier spécifié et à la console (le /b commutateur). L’application définit un indicateur nommé isRedirected pour indiquer si la sortie doit être envoyée à un fichier, et un indicateur nommé isBoth pour indiquer que la sortie doit être envoyée à la console. Notez que l’exemple F# utilise une fonction récursive pour analyser les arguments.
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");
}
}
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 Example
Public Sub Main()
' Initialize flag variables.
Dim isRedirected, isBoth As Boolean
Dim fileName As String = ""
Dim sw As StreamWriter = Nothing
' Get any command line arguments.
Dim args() As String = Environment.GetCommandLineArgs()
' Handle any arguments.
If args.Length > 1 Then
For ctr = 1 To args.Length - 1
Dim arg As String = args(ctr)
If arg.StartsWith("/") OrElse arg.StartsWith("-") Then
Select Case arg.Substring(1).ToLower()
Case "f"
isRedirected = True
If args.Length < ctr + 2 Then
ShowSyntax("The /f switch must be followed by a filename.")
Exit Sub
End If
fileName = args(ctr + 1)
ctr += 1
Case "b"
isBoth = True
Case Else
ShowSyntax(String.Format("The {0} switch is not supported",
args(ctr)))
Exit Sub
End Select
End If
Next
End If
' If isBoth is True, isRedirected must be True.
If isBoth And Not isRedirected Then
ShowSyntax("The /f switch must be used if /b is used.")
Exit Sub
End If
' Handle output.
If isRedirected Then
sw = New StreamWriter(fileName)
If Not IsBoth Then
Console.SetOut(sw)
End If
End If
Dim msg As String = String.Format("Application began at {0}", Date.Now)
Console.WriteLine(msg)
If isBoth Then sw.WriteLine(msg)
Thread.Sleep(5000)
msg = String.Format("Application ended normally at {0}", Date.Now)
Console.WriteLine(msg)
If isBoth Then sw.WriteLine(msg)
If isRedirected Then sw.Close()
End Sub
Private Sub ShowSyntax(errMsg As String)
Console.WriteLine(errMsg)
Console.WriteLine()
Console.WriteLine("Syntax: Example [[/f <filename> [/b]]")
Console.WriteLine()
End Sub
End Module
Opérations booléennes et arithmétiques
Une valeur booléenne est parfois utilisée pour indiquer la présence d’une condition qui déclenche un calcul mathématique. Par exemple, une hasShippingCharge variable peut servir d’indicateur pour indiquer s’il faut ajouter des frais d’expédition à un montant de facture.
Étant donné qu’une opération avec une false valeur n’a aucun effet sur le résultat d’une opération, il n’est pas nécessaire de convertir la valeur booléenne en valeur intégrale à utiliser dans l’opération mathématique. Au lieu de cela, vous pouvez utiliser une logique conditionnelle.
L’exemple suivant calcule un montant qui se compose d’un sous-total, d’un frais d’expédition et de frais de service facultatifs. La hasServiceCharge variable détermine si les frais de service sont appliqués. Au lieu de convertir hasServiceCharge en valeur numérique et de la multiplier par le montant des frais de service, l’exemple utilise une logique conditionnelle pour ajouter le montant des frais de service, le cas échéant.
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.
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 Example
Public Sub Main()
Dim hasServiceCharges() As Boolean = { True, False }
Dim subtotal As Decimal = 120.62d
Dim shippingCharge As Decimal = 2.50d
Dim serviceCharge As Decimal = 5.00d
For Each hasServiceCharge In hasServiceCharges
Dim total As Decimal = subtotal + shippingCharge +
If(hasServiceCharge, serviceCharge, 0)
Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.",
total, hasServiceCharge)
Next
End Sub
End Module
' The example displays output like the following:
' hasServiceCharge = True: The total is $128.12.
' hasServiceCharge = False: The total is $123.12.
Booleans et interopérabilité
Bien que le marshaling des types de données de base vers COM soit généralement simple, le Boolean type de données est une exception. Vous pouvez appliquer l’attribut MarshalAsAttribute pour marshaler le Boolean type à l’une des représentations suivantes :
| Type d'énumération | Format non managé |
|---|---|
| UnmanagedType.Bool | Valeur entière de 4 octets, où toute valeur différente de zéro représente true et 0 représente false. Il s’agit du format par défaut d’un Boolean champ dans une structure et d’un Boolean paramètre dans les appels d’appel de plateforme. |
| UnmanagedType.U1 | Valeur entière de 1 octet, où 1 représente true et 0 représente false. |
| UnmanagedType.VariantBool | Valeur entière de 2 octets, où -1 représente true et 0 représente false. Il s’agit du format par défaut d’un Boolean paramètre dans les appels d’interopérabilité COM. |
Champs
| FalseString |
Représente la valeur booléenne |
| TrueString |
Représente la valeur booléenne |
Méthodes
| CompareTo(Boolean) |
Compare cette instance à un objet Boolean spécifié et retourne un entier qui indique la relation entre ces deux éléments. |
| CompareTo(Object) |
Compare cette instance à l'objet spécifié et retourne un entier qui indique la relation entre ces deux éléments. |
| Equals(Boolean) |
Retourne une valeur indiquant si cette instance est égale à un objet Boolean spécifié. |
| Equals(Object) |
Retourne une valeur indiquant si cette instance équivaut à un objet spécifié. |
| GetHashCode() |
Retourne le code de hachage de cette instance. |
| GetTypeCode() |
Retourne le code de type pour le type valeur Boolean. |
| Parse(ReadOnlySpan<Char>) |
Convertit la représentation d’étendue spécifiée d’une valeur logique en son équivalent Boolean. |
| Parse(String) |
Convertit la représentation sous forme de chaîne spécifiée d’une valeur logique en son équivalent Boolean. |
| ToString() |
Convertit la valeur de cette instance en sa représentation sous forme de chaîne équivalente ("True" ou "False"). |
| ToString(IFormatProvider) |
Convertit la valeur de cette instance en sa représentation sous forme de chaîne équivalente ("True" ou "False"). |
| TryFormat(Span<Char>, Int32) |
Tente de mettre en forme la valeur de l’instance booléenne actuelle dans la plage de caractères fournie. |
| TryParse(ReadOnlySpan<Char>, Boolean) |
Tente de convertir la représentation de plage sous forme de chaîne d'une valeur logique en son Boolean équivalent. |
| TryParse(String, Boolean) |
Tente de convertir la représentation sous forme de chaîne d'une valeur logique en son Boolean équivalent. |
Implémentations d’interfaces explicites
| IComparable.CompareTo(Object) |
Compare l'instance actuelle à un autre objet du même type et retourne un entier qui indique si l'instance actuelle précède ou suit un autre objet ou se trouve à la même position que ce dernier dans l'ordre de tri. |
| IConvertible.GetTypeCode() |
Retourne le TypeCode de cette instance. |
| IConvertible.ToBoolean(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToBoolean(IFormatProvider). |
| IConvertible.ToByte(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToByte(IFormatProvider). |
| IConvertible.ToChar(IFormatProvider) |
Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException. |
| IConvertible.ToDateTime(IFormatProvider) |
Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException. |
| IConvertible.ToDecimal(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToDecimal(IFormatProvider). |
| IConvertible.ToDouble(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToDouble(IFormatProvider). |
| IConvertible.ToInt16(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToInt16(IFormatProvider). |
| IConvertible.ToInt32(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToInt32(IFormatProvider). |
| IConvertible.ToInt64(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToInt64(IFormatProvider). |
| IConvertible.ToSByte(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToSByte(IFormatProvider). |
| IConvertible.ToSingle(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToSingle(IFormatProvider). |
| IConvertible.ToString(IFormatProvider) |
Convertit la valeur de cette instance en une chaîne équivalente, en utilisant les informations de mise en forme propres à la culture spécifiées. |
| IConvertible.ToType(Type, IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToType(Type, IFormatProvider). |
| IConvertible.ToUInt16(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToUInt16(IFormatProvider). |
| IConvertible.ToUInt32(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToUInt32(IFormatProvider). |
| IConvertible.ToUInt64(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToUInt64(IFormatProvider). |
| IParsable<Boolean>.Parse(String, IFormatProvider) |
Analyse une chaîne en une valeur. |
| IParsable<Boolean>.TryParse(String, IFormatProvider, Boolean) |
Représente une valeur booléenne ( |
| ISpanParsable<Boolean>.Parse(ReadOnlySpan<Char>, IFormatProvider) |
Analyse une étendue de caractères dans une valeur. |
| ISpanParsable<Boolean>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Boolean) |
Représente une valeur booléenne ( |
S’applique à
Cohérence de thread
Tous les membres de ce type sont thread-safe. Les membres qui semblent modifier instance’état retournent en fait une nouvelle instance initialisée avec la nouvelle valeur. Comme pour tout autre type, la lecture et l’écriture dans une variable partagée qui contient une instance de ce type doivent être protégées par un verrou pour garantir la sécurité des threads.
Commentaires
Envoyer et afficher des commentaires pour