Boolean Struktura

Definicja

Reprezentuje wartość logiczną (true lub false).Represents a Boolean (true or false) value.

public value class Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
type bool = struct
    interface IConvertible
Public Structure Boolean
Implements IComparable, IComparable(Of Boolean), IConvertible, IEquatable(Of Boolean)
Dziedziczenie
Boolean
Atrybuty
Implementuje

Uwagi

Wystąpienie Boolean może mieć jedną z dwóch wartości: truelub false.A Boolean instance can have either of two values: true, or false.

Struktura Boolean zawiera metody, które obsługują następujące zadania:The Boolean structure provides methods that support the following tasks:

W poniższych sekcjach opisano te zadania i inne szczegóły dotyczące użycia:The following sections explain these tasks and other usage details:

Formatowanie wartości logicznych Formatting Boolean values
Konwertowanie na i z wartości logicznych Converting to and from Boolean values
Analizowanie wartości logicznych Parsing Boolean values
Porównywanie wartości logicznych Comparing Boolean values
Praca z wartościami logicznymi w postaci wartości binarnych Working with Booleans as binary values
Wykonywanie operacji przy użyciu wartości logicznych Performing operations with Boolean values
Wartości logiczne i międzyoperacyjnośćBooleans and Interop

Formatowanie wartości logicznychFormatting Boolean values

Ciąg reprezentujący Boolean ma wartość "true" dla true wartości lub "false" dla wartości false.The string representation of a Boolean is either "True" for a true value or "False" for a false value. Ciąg reprezentujący wartość Boolean jest definiowany przy użyciu pól TrueString i FalseString tylko do odczytu.The string representation of a Boolean value is defined by the read-only TrueString and FalseString fields.

Metoda ToString służy do konwertowania wartości logicznych na ciągi.You use the ToString method to convert Boolean values to strings. Struktura logiczna zawiera dwa przeciążenia ToString: bezparametrowa Metoda ToString() i Metoda ToString(IFormatProvider), która zawiera parametr kontrolujący formatowanie.The Boolean structure includes two ToString overloads: the parameterless ToString() method and the ToString(IFormatProvider) method, which includes a parameter that controls formatting. Jednak ponieważ ten parametr jest ignorowany, dwa przeciążenia generują identyczne ciągi.However, because this parameter is ignored, the two overloads produce identical strings. Metoda ToString(IFormatProvider) nie obsługuje formatowania z uwzględnieniem kultury.The ToString(IFormatProvider) method does not support culture-sensitive formatting.

Poniższy przykład ilustruje formatowanie przy użyciu metody ToString.The following example illustrates formatting with the ToString method. Należy zauważyć, że w przykładzie jest stosowana funkcja formatowania złożonego , więc metoda ToString jest wywoływana niejawnie.Note that the example uses the composite formatting feature, so the ToString method is called implicitly.

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

Ze względu na to, że struktura Boolean może mieć tylko dwie wartości, można łatwo dodać niestandardowe formatowanie.Because the Boolean structure can have only two values, it is easy to add custom formatting. W przypadku prostego formatowania niestandardowego, w którym inne literały ciągu są zastępowane dla "true" i "false", można użyć dowolnej funkcji oceny warunkowej obsługiwanej przez język, na przykład operatora warunkowego w C# lub operatora if w Visual Basic.For simple custom formatting in which other string literals are substituted for "True" and "False", you can use any conditional evaluation feature supported by your language, such as the conditional operator in C# or the If operator in Visual Basic. Poniższy przykład używa tej techniki do formatowania wartości Boolean jako "yes" i "No", a nie "true" i "false".The following example uses this technique to format Boolean values as "Yes" and "No" rather than "True" and "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 operacji formatowania niestandardowego, w tym formatowania z uwzględnieniem kultury, można wywołać metodę String.Format(IFormatProvider, String, Object[]) i wprowadzić implementację ICustomFormatter.For more complex custom formatting operations, including culture-sensitive formatting, you can call the String.Format(IFormatProvider, String, Object[]) method and provide an ICustomFormatter implementation. Poniższy przykład implementuje interfejsy ICustomFormatter i IFormatProvider, aby zapewnić specyficzne dla kultury ciągi logiczne dla kultur angielskiej (Stany Zjednoczone), francuski (Francja) i rosyjski (Rosja).The following example implements the ICustomFormatter and IFormatProvider interfaces to provide culture-sensitive Boolean strings for the English (United States), French (France), and Russian (Russia) cultures.

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.Optionally, you can use resource files to define culture-specific Boolean strings.

Konwertowanie do i z wartości logicznychConverting to and from Boolean values

Struktura Boolean implementuje interfejs IConvertible.The Boolean structure implements the IConvertible interface. W związku z tym można użyć klasy Convert do wykonywania konwersji między wartością Boolean i dowolnym innym typem pierwotnym w programie .NET lub można wywołać jawne implementacje struktury Boolean.As a result, you can use the Convert class to perform conversions between a Boolean value and any other primitive type in .NET, or you can call the Boolean structure's explicit implementations. Jednak konwersje między Boolean i następujące typy nie są obsługiwane, więc odpowiednie metody konwersji zgłaszają wyjątek InvalidCastException:However, conversions between a Boolean and the following types are not supported, so the corresponding conversion methods throw an InvalidCastException exception:

Wszystkie konwersje z liczb całkowitych lub zmiennoprzecinkowych na wartości logiczne konwertują wartości niezerowe na wartości true i zero, aby false.All conversions from integral or floating-point numbers to Boolean values convert non-zero values to true and zero values to false. Poniższy przykład ilustruje to przez wywołanie wybranych przeciążeń klasy Convert.ToBoolean.The following example illustrates this by calling selected overloads of the Convert.ToBoolean class.

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 konwersji z wartości zmiennoprzecinkowych na wartości logiczne, metody konwersji wykonują dokładne porównanie z zerem.When converting from floating-point values to Boolean values, the conversion methods perform an exact comparison with zero. Jeśli wartość zmiennoprzecinkowa utraciła dokładność, wynik może być nieoczekiwany.If the floating-point value has lost precision, the result can be unexpected. Jest to zilustrowane w poniższym przykładzie, w którym zmienna Double, której wartość powinna być równa zero, jest konwertowana na wartość logiczną.This is illustrated in the following example, in which a Double variable whose value should be zero is converted to a Boolean value. Jak pokazano w przykładzie, wynik jest true ponieważ powtórzone Dodatki 0,2 spowodowały utratę dokładności.As the example shows, the result is true because repeated additions of 0.2 have resulted in a loss of precision.

Podczas konwersji z wartości logicznych na wartość liczbową metody konwersji klasy Convert konwertują true na 1 i false na 0.When converting from Boolean to numeric values, the conversion methods of the Convert class convert true to 1 and false to 0. Jednak funkcje konwersji Visual Basic konwertują true na 255 (w przypadku konwersji do wartości Byte) lub-1 (dla wszystkich innych konwersji liczbowych).However, Visual Basic conversion functions convert true to either 255 (for conversions to Byte values) or -1 (for all other numeric conversions). Poniższy przykład konwertuje true na wartości liczbowe przy użyciu metody Convert i, w przypadku Visual Basic przykład, przy użyciu własnego operatora konwersji języka Visual Basic.The following example converts true to numeric values by using a Convert method, and, in the case of the Visual Basic example, by using the Visual Basic language's own conversion operator.

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 przeprowadzić konwersje z Boolean na wartości ciągu, zobacz sekcję Formatowanie wartości logicznych .For conversions from Boolean to string values, see the Formatting Boolean Values section. W przypadku konwersji z ciągów na wartości Boolean, zobacz sekcję Analizowanie wartości logicznych .For conversions from strings to Boolean values, see the Parsing Boolean Values section.

Analizowanie wartości logicznychParsing Boolean values

Struktura Boolean obejmuje dwie statyczne metody analizy, Parse i TryParse, które konwertują ciąg na wartość logiczną.The Boolean structure includes two static parsing methods, Parse and TryParse, that convert a string to a Boolean value. Reprezentacja wartości logicznej w postaci ciągu jest definiowana przez niezależne od wielkości liter wartości pól TrueString i FalseString, które są odpowiednio "true" i "false".The string representation of a Boolean value is defined by the case-insensitive equivalents of the values of the TrueString and FalseString fields, which are "True" and "False", respectively. Innymi słowy jedynymi ciągami, które są analizowane pomyślnie, są "true", "false", "true", "false" lub "reprezentowany przypadek mieszany".In other words, the only strings that parse successfully are "True", "False", "true", "false", or some mixed-case equivalent. Nie można pomyślnie przeanalizować ciągów liczbowych, takich jak "0" lub "1".You cannot successfully parse numeric strings such as "0" or "1". Podczas porównywania ciągów nie są brane pod uwagę początkowe lub końcowe znaki białych znaków.Leading or trailing white-space characters are not considered when performing the string comparison.

W poniższym przykładzie zastosowano metody Parse i TryParse, aby przeanalizować liczbę ciągów.The following example uses the Parse and TryParse methods to parse a number of strings. Należy zauważyć, że można pomyślnie przeanalizować tylko wartości "true" i "false" bez uwzględniania wielkości liter.Note that only the case-insensitive equivalents of "True" and "False" can be successfully parsed.

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'

W przypadku programowania w Visual Basic można użyć funkcji CBool do przekonwertowania ciągu reprezentującego liczbę na wartość logiczną.If you are programming in Visual Basic, you can use the CBool function to convert the string representation of a number to a Boolean value. "0" jest konwertowany na false, a ciąg reprezentujący dowolną wartość różną od zera jest konwertowany na true."0" is converted to false, and the string representation of any non-zero value is converted to true. Jeśli nie korzystasz z programowania w Visual Basic, musisz przekonwertować ciąg liczbowy na liczbę przed przekonwertowaniem jej na wartość logiczną.If you are not programming in Visual Basic, you must convert your numeric string to a number before converting it to a Boolean. Poniższy przykład ilustruje to, konwertując tablicę liczb całkowitych na wartości logiczne.The following example illustrates this by converting an array of integers to Boolean values.

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 logicznychComparing Boolean values

Ponieważ wartości logiczne są true lub false, istnieje niewielki powód, aby jawnie wywołać metodę CompareTo, która wskazuje, czy wystąpienie jest większe niż, mniejsze niż lub równe określonej wartości.Because Boolean values are either true or false, there is little reason to explicitly call the CompareTo method, which indicates whether an instance is greater than, less than, or equal to a specified value. Zazwyczaj, aby porównać dwie zmienne logiczne, należy wywołać metodę Equals lub użyć operatora równości języka.Typically, to compare two Boolean variables, you call the Equals method or use your language's equality operator.

Jeśli jednak chcesz porównać zmienną logiczną z literalną wartością logiczną true lub false, nie trzeba wykonać jawnego porównania, ponieważ wynikiem obliczania wartości logicznej jest wartość logiczna.However, when you want to compare a Boolean variable with the literal Boolean value true or false, it is not necessary to do an explicit comparison, because the result of evaluating a Boolean value is that Boolean value. Na przykład wyrażeniaFor example, the expressions

if (booleanValue) {
If booleanValue Then

andand

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.

są równoważne, ale drugi jest bardziej zwarty.are equivalent, but the second is more compact. Jednak obie techniki oferują porównywalną wydajność.However, both techniques offer comparable performance.

Praca z wartościami logicznymi w postaci wartości binarnychWorking with Booleans as binary values

Wartość logiczna zajmuje jeden bajt pamięci, jak pokazano w poniższym C# przykładzie.A Boolean value occupies one byte of memory, as the following C# example shows. Przykład musi być skompilowany przy użyciu przełącznika /unsafe.The example must be compiled with the /unsafe switch.

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 bajtów jest używany do reprezentowania jego wartości.The byte's low-order bit is used to represent its value. Wartość 1 reprezentuje true; wartość 0 reprezentuje false.A value of 1 represents true; a value of 0 represents false.

Ostrzeżenie

Możesz użyć struktury System.Collections.Specialized.BitVector32 do pracy z zestawami wartości logicznych.You can use the System.Collections.Specialized.BitVector32 structure to work with sets of Boolean values.

Można przekonwertować wartość logiczną na reprezentację binarną, wywołując metodę BitConverter.GetBytes(Boolean).You can convert a Boolean value to its binary representation by calling the BitConverter.GetBytes(Boolean) method. Metoda zwraca tablicę bajtową z pojedynczym elementem.The method returns a byte array with a single element. Aby przywrócić wartość logiczną z reprezentacji binarnej, można wywołać metodę BitConverter.ToBoolean(Byte[], Int32).To restore a Boolean value from its binary representation, you can call the BitConverter.ToBoolean(Byte[], Int32) method.

Poniższy przykład wywołuje metodę BitConverter.GetBytes, aby przekonwertować wartość logiczną na jej reprezentację binarną i wyświetlić poszczególne bity wartości, a następnie wywołuje metodę BitConverter.ToBoolean w celu przywrócenia wartości z jej reprezentacji binarnej.The following example calls the BitConverter.GetBytes method to convert a Boolean value to its binary representation and displays the individual bits of the value, and then calls the BitConverter.ToBoolean method to restore the value from its binary representation.

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 logicznychPerforming operations with Boolean values

W tej sekcji pokazano, jak w aplikacjach są używane wartości logiczne.This section illustrates how Boolean values are used in apps. W pierwszej sekcji omówiono jego użycie jako flagę.The first section discusses its use as a flag. Druga ilustruje jego użycie w operacjach arytmetycznych.The second illustrates its use for arithmetic operations.

Wartości logiczne jako flagiBoolean values as flags

Zmienne logiczne są najczęściej używane jako flagi, aby sygnalizować obecność lub brak pewnego warunku.Boolean variables are most commonly used as flags, to signal the presence or absence of some condition. Na przykład, w metodzie String.Compare(String, String, Boolean), końcowy parametr, ignoreCase, jest flagą wskazującą, czy porównanie dwóch ciągów nie uwzględnia wielkości liter (ignoreCase jest true) czy z uwzględnieniem wielkości liter (ignoreCase jest false).For example, in the String.Compare(String, String, Boolean) method, the final parameter, ignoreCase, is a flag that indicates whether the comparison of two strings is case-insensitive (ignoreCase is true) or case-sensitive (ignoreCase is false). Wartość flagi można następnie oszacować w instrukcji warunkowej.The value of the flag can then be evaluated in a conditional statement.

W poniższym przykładzie użyto prostej aplikacji konsolowej do zilustrowania użycia zmiennych logicznych jako flag.The following example uses a simple console app to illustrate the use of Boolean variables as flags. Aplikacja akceptuje parametry wiersza polecenia, które umożliwiają przekierowywanie danych wyjściowych do określonego pliku (przełącznik /f), które umożliwiają wysyłanie danych wyjściowych zarówno do określonego pliku, jak i do konsoli programu (przełącznik /b).The app accepts command-line parameters that enable output to be redirected to a specified file (the /f switch), and that enable output to be sent both to a specified file and to the console (the /b switch). Aplikacja definiuje flagę o nazwie isRedirected, aby wskazać, czy dane wyjściowe mają być wysyłane do pliku, oraz flagę o nazwie isBoth, aby wskazać, że dane wyjściowe powinny być wysyłane do konsoli.The app defines a flag named isRedirected to indicate whether output is to be sent to a file, and a flag named isBoth to indicate that output should be sent to the console.

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 logiczne i arytmetyczneBooleans and arithmetic operations

Wartość logiczna jest czasami używana do wskazania obecności warunku, który wyzwala obliczenie matematyczne.A Boolean value is sometimes used to indicate the presence of a condition that triggers a mathematical calculation. Na przykład zmienna hasShippingCharge może stanowić flagę, aby wskazać, czy dodać opłaty za wysyłkę do kwoty faktury.For example, a hasShippingCharge variable might serve as a flag to indicate whether to add shipping charges to an invoice amount.

Ponieważ operacja o wartości false nie ma wpływu na wynik operacji, nie jest konieczne przekonwertowanie wartości logicznej na wartość całkowitą do użycia w operacji matematycznej.Because an operation with a false value has no effect on the result of an operation, it is not necessary to convert the Boolean to an integral value to use in the mathematical operation. Zamiast tego można użyć logiki warunkowej.Instead, you can use conditional logic.

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ę.The following example computes an amount that consists of a subtotal, a shipping charge, and an optional service charge. Zmienna hasServiceCharge określa, czy jest naliczana opłata za usługę.The hasServiceCharge variable determines whether the service charge is applied. Zamiast konwersji hasServiceCharge na wartość liczbową i mnożyć ją przez kwotę opłaty za usługę, w przykładzie jest stosowana logika warunkowa w celu dodania kwoty opłaty za usługę, jeśli ma to zastosowanie.Instead of converting hasServiceCharge to a numeric value and multiplying it by the amount of the service charge, the example uses conditional logic to add the service charge amount if it is applicable.

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ści logiczne i międzyoperacyjnośćBooleans and interop

Kierowanie bazowych typów danych do modelu COM jest ogólnie proste, Boolean typem danych jest wyjątek.While marshaling base data types to COM is generally straightforward, the Boolean data type is an exception. Można zastosować MarshalAsAttribute atrybutu do organizowania typu Boolean do jednej z następujących reprezentacji:You can apply the MarshalAsAttribute attribute to marshal the Boolean type to any of the following representations:

Typ wyliczeniaEnumeration type Format niezarządzanyUnmanaged format
UnmanagedType.Bool Wartość 4-bajtowa liczba całkowita, gdzie każda wartość różna od zera reprezentuje true i 0 reprezentuje false.A 4-byte integer value, where any nonzero value represents true and 0 represents false. Jest to domyślny format pola Boolean w strukturze i parametru Boolean w wywołaniach wywołania platformy.This is the default format of a Boolean field in a structure and of a Boolean parameter in platform invoke calls.
UnmanagedType.U1 Wartość 1-bajtowa liczba całkowita, gdzie 1 reprezentuje true i 0 reprezentuje false.A 1-byte integer value, where the 1 represents true and 0 represents false.
UnmanagedType.VariantBool Wartość 2-bajtowa liczba całkowita, gdzie-1 reprezentuje true i 0 reprezentuje false.A 2-byte integer value, where -1 represents true and 0 represents false. Jest to domyślny format parametru Boolean w wywołaniach międzyoperacyjnych modelu COM.This is the default format of a Boolean parameter in COM interop calls.

Pola

FalseString

Reprezentuje wartość logiczną false jako ciąg.Represents the Boolean value false as a string. To pole jest tylko do odczytu.This field is read-only.

TrueString

Reprezentuje wartość logiczną true jako ciąg.Represents the Boolean value true as a string. To pole jest tylko do odczytu.This field is read-only.

Metody

CompareTo(Boolean)

Porównuje to wystąpienie do określonego obiektu Boolean i zwraca liczbę całkowitą, która wskazuje ich relację ze sobą.Compares this instance to a specified Boolean object and returns an integer that indicates their relationship to one another.

CompareTo(Object)

Porównuje to wystąpienie do określonego obiektu i zwraca liczbę całkowitą, która wskazuje ich relację ze sobą.Compares this instance to a specified object and returns an integer that indicates their relationship to one another.

Equals(Boolean)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi Boolean.Returns a value indicating whether this instance is equal to a specified Boolean object.

Equals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode()

Zwraca kod skrótu dla tego wystąpienia.Returns the hash code for this instance.

GetTypeCode()

Zwraca kod typu dla Boolean typu wartości.Returns the type code for the Boolean value type.

Parse(ReadOnlySpan<Char>)

Konwertuje określony reprezentację wartości logicznej na jej odpowiednik Boolean.Converts the specified span representation of a logical value to its Boolean equivalent.

Parse(String)

Konwertuje określony ciąg reprezentujący wartość logiczną na jej odpowiednik Boolean.Converts the specified string representation of a logical value to its Boolean equivalent.

ToString()

Konwertuje wartość tego wystąpienia na jego równoważną reprezentację w postaci ciągu („True” lub „False”).Converts the value of this instance to its equivalent string representation (either "True" or "False").

ToString(IFormatProvider)

Konwertuje wartość tego wystąpienia na jego równoważną reprezentację w postaci ciągu („True” lub „False”).Converts the value of this instance to its equivalent string representation (either "True" or "False").

TryFormat(Span<Char>, Int32)

Próbuje sformatować wartość bieżącego wystąpienia wartości logicznej do podanego zakresu znaków.Tries to format the value of the current boolean instance into the provided span of characters.

TryParse(ReadOnlySpan<Char>, Boolean)

Próbuje skonwertować reprezentację określonego zakresu wartości logicznej na jej odpowiednik Boolean.Tries to convert the specified span representation of a logical value to its Boolean equivalent.

TryParse(String, Boolean)

Próbuje przekonwertować określoną reprezentację ciągu wartości logicznej na jej Boolean odpowiedniki.Tries to convert the specified string representation of a logical value to its Boolean equivalent.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)
IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Ta konwersja nie jest obsługiwana.This conversion is not supported. Próba użycia tej metody powoduje zgłoszenie InvalidCastException.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDateTime(IFormatProvider)

Ta konwersja nie jest obsługiwana.This conversion is not supported. Próba użycia tej metody powoduje zgłoszenie InvalidCastException.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

Dotyczy

Bezpieczeństwo wątkowe

Wszystkie elementy członkowskie tego typu są bezpieczne wątkowo.All members of this type are thread safe. 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ą.Members that appear to modify instance state actually return a new instance initialized with the new value. 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.As with any other type, reading and writing to a shared variable that contains an instance of this type must be protected by a lock to guarantee thread safety.