Boolean Struktura

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Zestaw:

netstandard.dll

Zestaw:

mscorlib.dll

Reprezentuje wartość logiczną ( true lub false ).

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

public value class bool : IComparable, IConvertible

public value class bool : IComparable, IComparable<bool>, IEquatable<bool>

public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<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 IConvertible

[<System.Serializable>]
type bool = struct
    interface IConvertible

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type bool = struct
    interface IConvertible

type bool = struct

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

Public Structure Boolean
Implements IComparable, IConvertible

Public Structure Boolean
Implements IComparable, IComparable(Of Boolean), IEquatable(Of Boolean)

Dziedziczenie

Object

ValueType

Boolean

Atrybuty

SerializableAttribute ComVisibleAttribute

Implementuje

IComparable IComparable<Boolean> IConvertible IEquatable<Boolean>

Uwagi

Wystąpienie Boolean może mieć jedną z dwóch wartości: lub true false .

Struktura Boolean udostępnia metody, które obsługują następujące zadania:

• Konwertowanie wartości logicznych na ciągi: ToString

• Analizowanie ciągów w celu przekonwertowania ich na wartości logiczne: Parse i TryParse

• Porównywanie wartości: CompareTo i Equals

W poniższych sekcjach wyjaśniono te zadania i inne szczegóły użycia:

• Formatowanie wartości logicznych
• Konwertowanie na i z wartości logicznych
• Analizowanie wartości logicznych
• Porównywanie wartości logicznych
• Praca z wartościami logicznymi jako wartościami binarnymi
• Wykonywanie operacji przy użyciu wartości logicznych
• Wartość logiczna i międzyoptyk

Formatowanie wartości logicznych

Reprezentacja ciągu to Boolean "True" dla wartości lub true "False" dla false wartości. Reprezentacja ciągu wartości Boolean jest definiowana przez pola tylko do TrueString odczytu i FalseString .

Metoda służy ToString do konwertowania wartości logicznych na ciągi. Struktura logiczna zawiera dwa przeciążenia: metodę bez parametru i metodę , która zawiera ToString ToString() parametr sterujący ToString(IFormatProvider) formatowaniem. Jednak ponieważ ten parametr jest ignorowany, dwa przeciążenia dają identyczne ciągi. Metoda ToString(IFormatProvider) nie obsługuje formatowania wrażliwego na ustawienia kulturowe.

Poniższy przykład ilustruje formatowanie za pomocą ToString metody . Należy pamiętać, że w przykładzie użyto funkcji formatowania złożonego, więc ToString metoda jest wywoływana niejawnie.

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

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

Ponieważ struktura Boolean może mieć tylko dwie wartości, można łatwo dodać formatowanie niestandardowe. W przypadku prostego formatowania niestandardowego, w którym inne literały ciągu są zastępowane wartościami "True" i "False", można użyć dowolnej funkcji oceny warunkowej obsługiwanej przez język, takiej jak operator warunkowy w języku C# lub operator If w Visual Basic. W poniższym przykładzie ta technika jest używana do formatowania wartości Boolean jako "Tak" i "Nie", a nie "True" i "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

W przypadku bardziej złożonych niestandardowych operacji formatowania, w tym formatowania z uwzględnieniem kultury, możesz wywołać String.Format(IFormatProvider, String, Object[]) metodę i zapewnić ICustomFormatter implementację. W poniższym przykładzie zaimplementowano interfejsy i w celu zapewnienia ciągów logicznych logicznych ważnych dla kultury ICustomFormatter IFormatProvider angielskiej (Stany Zjednoczone), francuskiej (Francja) i rosyjskich (Rosyjski).

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': верно

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': верно

Opcjonalnie można użyć plików zasobów do zdefiniowania ciągów logicznych specyficznych dla kultury.

Konwertowanie na i z wartości logicznych

Struktura Boolean implementuje IConvertible interfejs. W związku z tym można użyć klasy do wykonania konwersji między wartością a dowolnym innym typem pierwotnym na platformie .NET lub wywołać jawne implementacje Convert Boolean Boolean struktury. Jednak konwersje między typami a i następującymi typami nie są obsługiwane, więc odpowiednie metody konwersji Boolean zgłaszają InvalidCastException wyjątek:

• Konwersja Boolean między Char metodami i Convert.ToBoolean(Char) Convert.ToChar(Boolean) (metody i )

• Konwersja Boolean między DateTime metodami i Convert.ToBoolean(DateTime) Convert.ToDateTime(Boolean) (metody i )

Wszystkie konwersje z liczb całkowitoliczbowych lub zmiennoprzecinków na wartości logiczne konwertują wartości niezerowe na , a true wartości zerowe na false . Poniższy przykład ilustruje to przez wywołanie wybranych przeciążeń Convert.ToBoolean klasy.

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

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

Podczas konwertowania z wartości logicznych na wartości liczbowe metody konwersji klasy są konwertowane na Convert true wartości 1 i false 0. Jednak funkcje Visual Basic konwersji są konwertowane na wartość 255 (w przypadku konwersji na wartości) lub true Byte -1 (dla wszystkich innych konwersji liczbowych). Poniższy przykład umożliwia konwersję na wartości liczbowe przy użyciu metody , a w przypadku przykładu Visual Basic przy użyciu operatora konwersji języka Visual Basic języka true Convert 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

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)

Aby uzyskać informacje na temat konwersji z na Boolean wartości ciągu, zobacz sekcję Formatowanie wartości logicznych. Aby uzyskać informacje na temat konwersji z ciągów na wartości, zobacz sekcję Boolean Analizowanie wartości logicznych.

Analizowanie wartości logicznych

Struktura Boolean zawiera dwie metody statycznej analizy i , które Parse TryParse konwertują ciąg na wartość logiczną. Reprezentacja ciągu wartości logicznych jest definiowana przez odpowiedniki wartości pól i bez uwzględniania liter, które mają odpowiednio wartości TrueString FalseString "True" i "False". Innymi słowy, jedynymi ciągami, które pomyślnie analizują, są ciągi "True", "False", "true", "false" lub niektóre odpowiedniki w różnych przypadkach. Nie można pomyślnie analizowania ciągów liczbowych, takich jak "0" lub "1". Wiodące lub końcowe znaki odstępu nie są rozważane podczas porównywania ciągów.

W poniższym przykładzie użyto metod i do Parse TryParse analizowania wielu ciągów. Należy pamiętać, że tylko odpowiedniki wartości "True" i "False" bez uwzględniania liter mogą być pomyślnie analizowane.

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'

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'

Jeśli programowanie jest Visual Basic, możesz użyć funkcji , aby przekonwertować reprezentację ciągu liczby na CBool wartość logiczną. Wartość "0" jest konwertowana na wartość , a reprezentacja ciągu dowolnej wartości false niezerowej jest konwertowana na true wartość . Jeśli nie programujesz w Visual Basic, musisz przekonwertować ciąg liczbowy na liczbę przed przekonwertowanie go na wartość logiczną. Poniższy przykład ilustruje to przez przekonwertowanie tablicy liczb całkowitych na wartości logiczne.

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

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

Porównywanie wartości logicznych

Ponieważ wartości logiczne są albo lub , nie ma powodu, aby jawnie wywołać metodę , która wskazuje, czy wystąpienie jest większe niż, mniejsze niż lub równe true false CompareTo określonej wartości. Zazwyczaj, aby porównać dwie zmienne logiczne, należy wywołać metodę lub użyć operatora Equals równości języka.

Jeśli jednak chcesz porównać zmienną logiczną z wartością logiczną literału lub , nie trzeba wykonać jawnego porównania, ponieważ wynikiem obliczenia wartości logicznych jest ta wartość true false logiczna. Na przykład wyrażenia

if (booleanValue == true) {

If booleanValue = True Then

oraz

if (booleanValue) {

If booleanValue Then

są równoważne, ale drugi jest bardziej kompaktowy. Jednak obie techniki oferują porównywalną wydajność.

Praca z wartościami logicznymi jako wartościami binarnymi

Wartość logiczna zajmuje jeden bajt pamięci, jak pokazano w poniższym przykładzie w języku C#. Przykład należy skompilować za pomocą /unsafe przełącznika .

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

Bit niskiej kolejności bajtu jest używany do reprezentowania jego wartości. Wartość 1 reprezentuje true wartość ; wartość 0 reprezentuje wartość false .

Porada

Za pomocą struktury System.Collections.Specialized.BitVector32 można pracować z zestawami wartości logicznych.

Wartość logiczną można przekonwertować na jej reprezentację binarną, wywołując BitConverter.GetBytes(Boolean) metodę . Metoda zwraca tablicę bajtów z pojedynczym elementem. Aby przywrócić wartość logiczną z jej reprezentacji binarnej, możesz wywołać BitConverter.ToBoolean(Byte[], Int32) metodę .

Poniższy przykład wywołuje metodę , aby przekonwertować wartość logiczną na jej reprezentację binarną i wyświetla poszczególne bity wartości, a następnie wywołuje metodę , aby przywrócić wartość z jej reprezentacji BitConverter.GetBytes BitConverter.ToBoolean binarnej.

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

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

Wykonywanie operacji przy użyciu wartości logicznych

W tej sekcji pokazano, jak wartości logiczne są używane w aplikacjach. W pierwszej sekcji omówiono jej użycie jako flagę. Drugi ilustruje jego użycie dla operacji arytmetycznych.

Wartości logiczne jako flagi

Zmienne logiczne są najczęściej używane jako flagi, aby zasygnalizować obecność lub brak jakiegoś warunku. Na przykład w metodzie ostatni parametr, , jest flagą, która wskazuje, czy w porównaniu dwóch ciągów nie jest uwzględniania wielkość liter ( jest ), czy z uwzględnianiem String.Compare(String, String, Boolean) wielkości liter ( jest ignoreCase ignoreCase true ignoreCase false ). Wartość flagi można następnie ocenić w instrukcji warunkowej.

W poniższym przykładzie użyto prostej aplikacji konsolowej, aby zilustrować użycie zmiennych logicznych jako flag. Aplikacja akceptuje parametry wiersza polecenia, które umożliwiają przekierowywanie danych wyjściowych do określonego pliku (przełącznika) i które umożliwiają wysłania danych wyjściowych zarówno do określonego pliku, jak i do konsoli /f /b (przełącznika). Aplikacja definiuje flagę o nazwie , aby wskazać, czy dane wyjściowe mają być wysyłane do pliku, oraz flagę o nazwie wskazującą, że dane wyjściowe powinny być isRedirected isBoth wysyłane do konsoli.

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");
   }
}

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

Operacje arytmetyczne i arytmetyczne

Wartość logiczna jest czasami używana do wskazania obecności warunku, który wyzwala obliczenie matematyczne. Na przykład hasShippingCharge zmienna może służyć jako flaga wskazująca, czy dodać opłaty za wysyłkę do kwoty faktury.

Ponieważ operacja z wartością nie ma wpływu na wynik operacji, nie trzeba konwertować wartości logicznych na wartość całkowitą do użycia w operacji false matematycznej. Zamiast tego można użyć logiki warunkowej.

Poniższy przykład oblicza kwotę, która składa się z sumy częściowej, opłaty za wysyłkę i opcjonalnej opłaty za usługę. Zmienna hasServiceCharge określa, czy opłata za usługę jest stosowana. Zamiast konwertowania na wartość liczbową i mnożenia jej przez kwotę opłaty za usługę, w przykładzie użyto logiki warunkowej w celu dodania kwoty opłaty za usługę, jeśli hasServiceCharge ma to zastosowanie.

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.

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.

Wartość logiczna i międzyetyk

Chociaż marshaling podstawowych typów danych do com jest zwykle prosty, Boolean typ danych jest wyjątkiem. Atrybut można zastosować MarshalAsAttribute do marshalalu Boolean typu do dowolnej z następujących reprezentacji:

Typ wyliczenia	Format niezamanagedowany
UnmanagedType.Bool	4-bajtowa wartość całkowita, gdzie dowolna wartość niezerowa reprezentuje wartość , a true wartość 0 oznacza false wartość . Jest to domyślny format pola w strukturze i parametru Boolean Boolean w wywołaniach wywołań platformy.
UnmanagedType.U1	Wartość 1-bajtowej liczby całkowitej, gdzie 1 reprezentuje wartość , a true wartość 0 reprezentuje false wartość .
UnmanagedType.VariantBool	Wartość 2-bajtowej liczby całkowitej, gdzie -1 reprezentuje wartość , a true wartość 0 oznacza false wartość . Jest to domyślny format parametru Boolean w wywołaniach międzyoptyku COM.

Pola

FalseString	Reprezentuje wartość logiczną false jako ciąg. To pole jest tylko do odczytu.
TrueString	Reprezentuje wartość logiczną true jako ciąg. To pole jest tylko do odczytu.

Metody

CompareTo(Boolean)	Porównuje to wystąpienie z określonym obiektem i zwraca liczbę całkowitą, która Boolean wskazuje ich relację ze sobą.
CompareTo(Object)	Porównuje to wystąpienie z określonym obiektem i zwraca liczbę całkowitą, która wskazuje ich relację ze sobą.
Equals(Boolean)	Zwraca wartość wskazującą, czy to wystąpienie jest równe określoneowi Boolean obiektowi.
Equals(Object)	Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.
GetHashCode()	Zwraca wartość skrótu dla tego wystąpienia.
GetTypeCode()	Zwraca kod typu dla Boolean typu wartości.
Parse(ReadOnlySpan<Char>)	Konwertuje określoną reprezentację zakresu wartości logicznej na jej Boolean odpowiednik.
Parse(String)	Konwertuje określoną reprezentację ciągu wartości logicznej na jej Boolean odpowiednik.
ToString()	Konwertuje wartość tego wystąpienia na jego równoważną reprezentację w postaci ciągu („True” lub „False”).
ToString(IFormatProvider)	Konwertuje wartość tego wystąpienia na jego równoważną reprezentację w postaci ciągu („True” lub „False”).
TryFormat(Span<Char>, Int32)	Próbuje sformatować wartość bieżącego wystąpienia wartości logicznych do podanego zakresu znaków.
TryParse(ReadOnlySpan<Char>, Boolean)	Próbuje przekonwertować określoną reprezentację zakresu wartości logicznej na jej Boolean odpowiednik.
TryParse(String, Boolean)	Próbuje przekonwertować określoną reprezentację ciągu wartości logicznej na jej Boolean odpowiednik.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)	Porównuje bieżące wystąpienie z innym obiektem tego samego typu i zwraca liczbę całkowitą, która wskazuje, czy bieżące wystąpienie poprzedza, następuje po lub występuje w tym samym położeniu, co inny obiekt w porządku sortowania.
IConvertible.GetTypeCode()	Zwraca wartość TypeCode dla tego wystąpienia.
IConvertible.ToBoolean(IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToBoolean(IFormatProvider) .
IConvertible.ToByte(IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToByte(IFormatProvider) .
IConvertible.ToChar(IFormatProvider)	Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza wyjątek InvalidCastException .
IConvertible.ToDateTime(IFormatProvider)	Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza wyjątek InvalidCastException .
IConvertible.ToDecimal(IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToDecimal(IFormatProvider) .
IConvertible.ToDouble(IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToDouble(IFormatProvider) .
IConvertible.ToInt16(IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToInt16(IFormatProvider) .
IConvertible.ToInt32(IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToInt32(IFormatProvider) .
IConvertible.ToInt64(IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToInt64(IFormatProvider) .
IConvertible.ToSByte(IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToSByte(IFormatProvider) .
IConvertible.ToSingle(IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToSingle(IFormatProvider) .
IConvertible.ToString(IFormatProvider)	Konwertuje wartość tego wystąpienia na równoważny ciąg przy użyciu określonych informacji o formatowaniu specyficznych dla kultury.
IConvertible.ToType(Type, IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToType(Type, IFormatProvider) .
IConvertible.ToUInt16(IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToUInt16(IFormatProvider) .
IConvertible.ToUInt32(IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToUInt32(IFormatProvider) .
IConvertible.ToUInt64(IFormatProvider)	Aby uzyskać opis tego członka, zobacz ToUInt64(IFormatProvider) .

Bezpieczeństwo wątkowe

Wszystkie elementy członkowskie tego typu są bezpieczne wątkowo. Elementy członkowskie, które na pierwszy rzut oka modyfikują stan wystąpienia, w rzeczywistości zwracają nowe wystąpienie zainicjowane z nową wartością. Podobnie jak w przypadku innych typów odczytywanie i zapisywanie w udostępnionej zmiennej, która zawiera wystąpienie tego typu, musi być chronione przez blokadę w celu zagwarantowania bezpieczeństwa wątków.