Boolean Struktúra

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

Boolean.cs

Logikai (true vagy false) értéket jelöl.

public value class bool : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>, IParsable<bool>, ISpanParsable<bool>

public readonly struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>, IParsable<bool>, ISpanParsable<bool>

type bool = struct
    interface IConvertible
    interface IParsable<bool>
    interface ISpanParsable<bool>

Public Structure Boolean
Implements IComparable, IComparable(Of Boolean), IConvertible, IEquatable(Of Boolean), IParsable(Of Boolean), ISpanParsable(Of Boolean)

Öröklődés

Object

ValueType

Boolean

Megvalósítás

IComparable IComparable<Boolean> IConvertible IEquatable<Boolean> IParsable<Boolean> IParsable<TSelf> ISpanParsable<Boolean>

Megjegyzések

Egy Boolean példánynak két értéke lehet: true vagy false.

A Boolean struktúra olyan módszereket biztosít, amelyek támogatják a következő feladatokat:

• Logikai értékek konvertálása sztringekké: ToString
• Sztringek elemzése logikai értékekké alakításához: Parse és TryParse
• Értékek összehasonlítása: CompareTo és Equals

Ez a cikk ezeket a feladatokat és egyéb használati adatokat ismerteti.

Logikai értékek formázása

Egy Boolean sztring-ábrázolása "Igaz" egy true értékhez, vagy "Hamis" egy false értékhez. A Boolean érték szöveges ábrázolását az írásvédett TrueString és FalseString mezők határozzák meg.

A ToString metódus használatával sztringekké alakíthatja a logikai értékeket. A logikai struktúra két ToString túlterhelést tartalmaz: a paraméter nélküli ToString() metódust és a ToString(IFormatProvider) metódust, amely egy formázást vezérlő paramétert tartalmaz. Mivel azonban ezt a paramétert figyelmen kívül hagyja, a két túlterhelés azonos sztringeket eredményez. A ToString(IFormatProvider) metódus nem támogatja a kultúraérzékeny formázást.

Az alábbi példa a ToString metódus formázását szemlélteti. Vegye figyelembe, hogy a C# és a VB példái az összetett formázási funkciót használják, míg az F# példa karakterlánc interpolációtalkalmaz. Mindkét esetben a ToString metódus implicit módon van meghívva.

using System;

public class Example10
{
   public static void Main()
   {
      bool raining = false;
      bool busLate = true;

      Console.WriteLine($"It is raining: {raining}");
      Console.WriteLine($"The bus is late: {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

Mivel a Boolean struktúra csak két értékkel rendelkezhet, könnyen felvehet egyéni formázást. Az egyszerű egyéni formázás során, amikor más sztringkonstansok helyettesítik a "True" és "False" értékeket, használhatja a nyelv által támogatott feltételes kiértékelési funkciókat, például a feltételes operátor a C# nyelvben vagy a If operátort a Visual Basicben. Az alábbi példa ezzel a technikával formázza Boolean értékeket "Igen" és "Nem" értékként az "Igaz" és a "Hamis" helyett.

using System;

public class Example11
{
    public static void Main()
    {
        bool raining = false;
        bool busLate = true;

        Console.WriteLine($"It is raining: {(raining ? "Yes" : "No")}");
        Console.WriteLine($"The bus is late: {(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

Az összetettebb egyéni formázási műveletekhez, beleértve a kultúraérzékeny formázást, meghívhatja a String.Format(IFormatProvider, String, Object[]) metódust, és ICustomFormatter implementációt biztosíthat. Az alábbi példa az ICustomFormatter és IFormatProvider interfészeket implementálja, hogy kulturális szempontból érzékeny logikai sztringeket biztosítson az angol (Egyesült Államok), a francia (Franciaország) és az orosz (Oroszország) kultúrák számára.

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;
      return culture.Name switch 
     {
         "en-US" => value.ToString(),
         "fr-FR" => value ? "vrai" : "faux",
         "ru-RU" => value ? "верно" : "неверно",
         _  => 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': верно

Ha szükséges, erőforrásfájlokkal definiálhat kultúraspecifikus logikai sztringeket.

Logikai értékekre és -értékekből történő konvertálás

A Boolean szerkezet implementálja a IConvertible felületet. Ennek eredményeképpen a Convert osztály használatával konverziókat hajthat végre egy Boolean érték és a .NET bármely más primitív típusa között, vagy meghívhatja a Boolean struktúra explicit implementációit. A Boolean és a következő típusok közötti átalakítások azonban, nem támogatottak, ezért a megfelelő átalakítási módszerek egy InvalidCastException kivételt dobnak.

• Átalakítás Boolean és Char között (a Convert.ToBoolean(Char) és Convert.ToChar(Boolean) metódusok).

• Átalakítás Boolean és DateTime között (a Convert.ToBoolean(DateTime) és Convert.ToDateTime(Boolean) metódusok).

Az integrál- vagy lebegőpontos számok logikai értékké alakítása a nem nulla értékeket true, a nulla értékeket pedig falseértékké alakítja. Az alábbi példa ezt a Convert.ToBoolean osztály kijelölt túlterheléseinek meghívásával szemlélteti.

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

Logikai értékek numerikus értékekké való konvertálásakor az Convert osztály konvertálási módszerei a true-et 1-re és a false-t 0-ra konvertálják. A Visual Basic konverziós függvények azonban 255-höz (true értékekké való átalakításhoz) vagy -1 (minden más numerikus átalakításhoz) konvertálják a Byte. Az alábbi példa a true numerikus értékké alakítja egy Convert metódussal, a Visual Basic-példa esetében pedig a Visual Basic nyelv saját konverziós operátorával.

using System;

public class Example3
{
   public static void Main()
   {
      bool flag = true;

      byte byteValue;
      byteValue = Convert.ToByte(flag);
      Console.WriteLine($"{flag} -> {byteValue}");

      sbyte sbyteValue;
      sbyteValue = Convert.ToSByte(flag);
      Console.WriteLine($"{flag} -> {sbyteValue}");

      double dblValue;
      dblValue = Convert.ToDouble(flag);
      Console.WriteLine($"{flag} -> {dblValue}");

      int intValue;
      intValue = Convert.ToInt32(flag);
      Console.WriteLine($"{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)

A Boolean-ból sztringértékekké való konvertálásról a Logikai értékek formázása szakaszban talál. A sztringekből Boolean értékekké való konvertálást lásd a logikai értékek értelmezése szakaszban.

Logikai értékek elemzése

A Boolean struktúra két statikus elemzési módszert tartalmaz, Parse és TryParse, amelyek logikai értékké konvertálnak egy sztringet. A logikai érték sztringábrázolását a TrueString és FalseString mezők értékeinek kis- és nagybetűktől független megfelelői határozzák meg, amelyek "Igaz" és "Hamis". Más szóval a sikeres elemzések egyetlen karakterlánca az "Igaz", a "Hamis", az "igaz", a "hamis" vagy ezek vegyes betűmérettel írt változata. Nem elemezheti sikeresen a numerikus sztringeket, például a "0" vagy az "1" karakterláncot. A karakterlánc-összehasonlítás végrehajtásakor nem veszik figyelembe a kezdő vagy záró szóköz karaktereket.

Az alábbi példa a Parse és TryParse metódusokat használja számos sztring elemzéséhez. Vegye figyelembe, hogy csak a "True" és a "False" kis- és nagybetűkre érzéketlen megfelelői elemezhetők sikeresen.

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($"'{value}' --> {flag}");
         }
         catch (ArgumentException) {
            Console.WriteLine("Cannot parse a null string.");
         }
         catch (FormatException) {
            Console.WriteLine($"Cannot parse '{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($"'{value}' --> {flag}");
         else
            Console.WriteLine($"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'

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'

Ha a Visual Basicben programozza, a CBool függvénnyel egy szám sztringképét logikai értékké alakíthatja. A "0" falselesz, és a nem nulla értékek sztring-ábrázolása truelesz. Ha nem a Visual Basicben programozol, számmá kell konvertálnod a numerikus karakterláncot, mielőtt logikai értékké konvertálod. Az alábbi példa ezt szemlélteti az egész számok tömbjének logikai értékekké alakításával.

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 '{value}' to {result}");
         }
         else {
            Console.WriteLine($"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

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

Logikai értékek összehasonlítása

Mivel a logikai értékek vagy true vagy false, nincs sok ok a CompareTo metódus explicit meghívására, amely jelzi, hogy egy példány nagyobb, kisebb vagy egyenlő egy megadott értékkel. Általában két logikai változó összehasonlításához meghívja a Equals metódust, vagy használja a nyelv egyenlőségi operátorát.

Ha azonban egy logikai változót true vagy falseliterál logikai értékkel szeretne összehasonlítani, nem szükséges explicit összehasonlítást végezni, mert a logikai érték kiértékelésének eredménye az a logikai érték. A következő két kifejezés például egyenértékű, a második azonban tömörebb. Azonban mindkét technika hasonló teljesítményt nyújt.

if (booleanValue == true) {

if booleanValue = true then

If booleanValue = True Then

if (booleanValue) {

if booleanValue then

If booleanValue Then

Logikai értékek használata bináris értékként

A logikai érték egy bájtnyi memóriát foglal el, ahogy az alábbi példa is mutatja. A C#-példát a /unsafe kapcsolóval kell lefordítani.

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: {sizeof(BoolStruct)}");
         Console.WriteLine("Field offsets:");
         Console.WriteLine($"   flag1: {(bool*) &b.flag1 - addr}");
         Console.WriteLine($"   flag2: {(bool*) &b.flag2 - addr}");
         Console.WriteLine($"   flag3: {(bool*) &b.flag3 - addr}");
         Console.WriteLine($"   flag4: {(bool*) &b.flag4 - addr}");
         Console.WriteLine($"   flag5: {(bool*) &b.flag5 - addr}");
      }
   }
}
// The example displays the following output:
//       Size of BoolStruct: 5
//       Field offsets:
//          flag1: 0
//          flag2: 1
//          flag3: 2
//          flag4: 3
//          flag5: 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

A bájt alacsony sorrendű bitje az értékének megjelenítésére szolgál. Az 1 érték true; a 0 érték falsejelöl.

Jótanács

A System.Collections.Specialized.BitVector32 szerkezettel logikai értékek készleteivel dolgozhat.

A logikai értékeket bináris reprezentációvá alakíthatja a BitConverter.GetBytes(Boolean) metódus meghívásával. A metódus egyetlen elemet tartalmazó bájttömböt ad vissza. Ha vissza szeretne állítani egy logikai értéket a bináris ábrázolásából, meghívhatja a BitConverter.ToBoolean(Byte[], Int32) metódust.

Az alábbi példa meghívja a BitConverter.GetBytes metódust egy logikai érték bináris ábrázolására való konvertálásához, és megjeleníti az érték egyes bitjeinek értékét, majd meghívja a BitConverter.ToBoolean metódust, hogy visszaállítsa az értéket a bináris ábrázolásból.

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: {flag}");
            Console.WriteLine($"Binary value:   {value} ({GetBinaryString(value)})");
            // Restore the flag from its binary representation.
            bool newFlag = BitConverter.ToBoolean(new Byte[] { value }, 0);
            Console.WriteLine($"Restored value: {newFlag}{Environment.NewLine}");
        }
    }

    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}", newFlag)
            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

Műveletek végrehajtása logikai értékekkel

Ez a szakasz bemutatja, hogyan használják a logikai értékeket az alkalmazások. Az első szakasz a jelölőként való használatát ismerteti. A második az aritmetikai műveletekhez való használatát mutatja be.

Logikai értékek jelölőként

A logikai változókat leggyakrabban jelzőkként használják, amelyek valamilyen feltétel meglétét vagy hiányát jelzik. A String.Compare(String, String, Boolean) metódusban például a végső paraméter, a ignoreCase, egy olyan jelölő, amely jelzi, hogy a két sztring összehasonlítása nem veszi figyelembe a kis- és nagybetűket (ignoreCasetrue), vagy figyelembe veszi a kis- és nagybetűket (ignoreCasefalse). A jelölő értéke ezután kiértékelhető egy feltételes utasításban.

Az alábbi példa egy egyszerű konzolalkalmazással szemlélteti a logikai változók jelölőként való használatát. Az alkalmazás olyan parancssori paramétereket fogad el, amelyek lehetővé teszik a kimenet átirányítását egy adott fájlba (a /f kapcsolóba), és amelyek lehetővé teszik a kimenet elküldését egy adott fájlba és a konzolra (a /b kapcsolóra). Az alkalmazás definiál egy isRedirected nevű jelzőt, amely jelzi, hogy a kimenetet fájlba kell-e küldeni, és egy isBoth nevű jelzőt, amely jelzi, hogy a kimenetet el kell küldeni a konzolra. Az F# példa egy rekurzív függvényt használ az argumentumok elemzéséhez.

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

Logikai és aritmetikai műveletek

Néha egy logikai érték jelzi egy matematikai számítást kiváltó feltétel meglétét. Egy hasShippingCharge változó például jelölőként szolgálhat, amely jelzi, hogy a szállítási díjakat hozzá kell-e adni egy számlaösszeghez.

Mivel egy false értékkel rendelkező műveletnek nincs hatása egy művelet eredményére, nem szükséges a logikai értéket a matematikai műveletben használandó szerves értékké alakítani. Ehelyett használhat feltételes logikát.

Az alábbi példa egy részösszegből, szállítási díjból és opcionális szolgáltatási díjból álló összeget számít ki. A hasServiceCharge változó határozza meg, hogy a szolgáltatásdíj van-e alkalmazva. A hasServiceCharge numerikus értékké alakítása és a szolgáltatási díj összegével való szorzása helyett a példa feltételes logikával adja hozzá a szolgáltatási díj összegét, ha alkalmazható.

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 = {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.

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.

Logikai értékek és interoperabilitás

Bár az alapadattípusok COM-ba történő beállítása általában egyszerű, a Boolean adattípus kivétel. A MarshalAsAttribute attribútumot a Boolean típus leképezésére használhatja a következő ábrázolások bármelyikére:

Számbavétel típusa	Nem felügyelt formátum
UnmanagedType.Bool	Egy 4 bájt hosszúságú egész szám, amelyben bármelyik nem nulla érték true, a 0 pedig false. Ez egy struktúrában lévő Boolean mező és egy Boolean paraméter alapértelmezett formátuma a platformhívási hívásokban.
UnmanagedType.U1	Egy 1 bájtos egész szám, amelyben az 1 true, a 0 pedig false.
UnmanagedType.VariantBool	Egy 2 bájtos egész szám, amelyben -1 true, a 0 pedig false. Ez egy Boolean paraméter alapértelmezett formátuma com-interop hívásokban.

Mezők

Name	Description
FalseString	A logikai értéket false sztringként jelöli. Ez a mező csak olvasható.
TrueString	A logikai értéket true sztringként jelöli. Ez a mező csak olvasható.

Metódusok

Name	Description
CompareTo(Boolean)	Összehasonlítja ezt a példányt egy adott Boolean objektummal, és egy egész számot ad vissza, amely jelzi az egymáshoz való viszonyukat.
CompareTo(Object)	Összehasonlítja ezt a példányt egy adott objektummal, és egy egész számot ad vissza, amely jelzi az egymáshoz való viszonyukat.
Equals(Boolean)	Egy értéket ad vissza, amely jelzi, hogy ez a példány egyenlő-e egy adott Boolean objektummal.
Equals(Object)	Egy értéket ad vissza, amely jelzi, hogy ez a példány egyenlő-e egy adott objektummal.
GetHashCode()	A példány kivonatkódját adja vissza.
GetTypeCode()	Az értéktípus típuskódját Boolean adja vissza.
Parse(ReadOnlySpan<Char>)	Egy logikai érték megadott span-ábrázolását konvertálja annak megfelelőjének Boolean .
Parse(String)	A logikai érték megadott sztring-ábrázolását konvertálja annak megfelelőjeként Boolean .
ToString()	Ennek a példánynak az értékét a megfelelő sztring-ábrázolásúvá alakítja (igaz vagy hamis).
ToString(IFormatProvider)	Ennek a példánynak az értékét a megfelelő sztring-ábrázolásúvá alakítja (igaz vagy hamis).
TryFormat(Span<Char>, Int32)	Megpróbálja formázni az aktuális logikai példány értékét a megadott karaktertartományba.
TryParse(ReadOnlySpan<Char>, Boolean)	Megpróbálja átalakítani egy logikai érték megadott span-ábrázolását annak megfelelőjeként Boolean .
TryParse(String, Boolean)	Megpróbálja átalakítani egy logikai érték megadott sztringképét annak megfelelőjeként Boolean .

Explicit interfész-implementációk

Name	Description
IConvertible.ToBoolean(IFormatProvider)	Ennek a tagnak a leírását lásd ToBoolean(IFormatProvider): .
IConvertible.ToByte(IFormatProvider)	Ennek a tagnak a leírását lásd ToByte(IFormatProvider): .
IConvertible.ToChar(IFormatProvider)	Ez az átalakítás nem támogatott. A metódus használatának megkísérlése egy InvalidCastException.
IConvertible.ToDateTime(IFormatProvider)	Ez az átalakítás nem támogatott. A metódus használatának megkísérlése egy InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Ennek a tagnak a leírását lásd ToDecimal(IFormatProvider): .
IConvertible.ToDouble(IFormatProvider)	Ennek a tagnak a leírását lásd ToDouble(IFormatProvider): .
IConvertible.ToInt16(IFormatProvider)	Ennek a tagnak a leírását lásd ToInt16(IFormatProvider): .
IConvertible.ToInt32(IFormatProvider)	Ennek a tagnak a leírását lásd ToInt32(IFormatProvider): .
IConvertible.ToInt64(IFormatProvider)	Ennek a tagnak a leírását lásd ToInt64(IFormatProvider): .
IConvertible.ToSByte(IFormatProvider)	Ennek a tagnak a leírását lásd ToSByte(IFormatProvider): .
IConvertible.ToSingle(IFormatProvider)	Ennek a tagnak a leírását lásd ToSingle(IFormatProvider): .
IConvertible.ToType(Type, IFormatProvider)	Ennek a tagnak a leírását lásd ToType(Type, IFormatProvider): .
IConvertible.ToUInt16(IFormatProvider)	Ennek a tagnak a leírását lásd ToUInt16(IFormatProvider): .
IConvertible.ToUInt32(IFormatProvider)	Ennek a tagnak a leírását lásd ToUInt32(IFormatProvider): .
IConvertible.ToUInt64(IFormatProvider)	Ennek a tagnak a leírását lásd ToUInt64(IFormatProvider): .
IParsable<Boolean>.Parse(String, IFormatProvider)	Egy sztringet egy értékbe elemez.
IParsable<Boolean>.TryParse(String, IFormatProvider, Boolean)	Logikai (true vagy false) értéket jelöl.
ISpanParsable<Boolean>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Több karakterből álló elemet elemez egy értékben.
ISpanParsable<Boolean>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Boolean)	Logikai (true vagy false) értéket jelöl.

Szálbiztonság

Az ilyen típusú tagok szálbiztosak. Azok a tagok, amelyek úgy tűnik, hogy módosítják a példány állapotát, valójában egy új példányt ad vissza, amely inicializálva van az új értékkel. Mint minden más típus esetén, az ilyen típusú példányt tartalmazó megosztott változókra való olvasást és írást zárolással kell védeni a szálbiztonság érdekében.