Boolean Boolean Boolean Boolean Struct

Definice

Představuje logickou hodnotutrue ( falsenebo).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)
Dědičnost
Atributy
Implementuje

Poznámky

Instance může mít jednu ze dvou hodnot: truenebo false. BooleanA Boolean instance can have either of two values: true, or false.

Boolean Struktura poskytuje metody, které podporují následující úlohy:The Boolean structure provides methods that support the following tasks:

Následující části popisují tyto úlohy a další podrobnosti o použití:The following sections explain these tasks and other usage details:

Formátování logických hodnot Formatting Boolean values
Převod na logické hodnoty a z nich Converting to and from Boolean values
Analýza logických hodnot Parsing Boolean values
Porovnávání logických hodnot Comparing Boolean values
Práce s logickými hodnotami jako binární hodnoty Working with Booleans as binary values
Provádění operací s logickými hodnotami Performing operations with Boolean values
Logické hodnoty a spolupráceBooleans and Interop

Formátování logických hodnotFormatting Boolean values

Řetězcová reprezentace Boolean hodnoty je "true" true pro hodnotu nebo false "false" pro hodnotu.The string representation of a Boolean is either "True" for a true value or "False" for a false value. Řetězcové vyjádření Boolean hodnoty je definováno pouze TrueString pro čtení a FalseString pole.The string representation of a Boolean value is defined by the read-only TrueString and FalseString fields.

Použijte ToString metodu pro převod logických hodnot na řetězce.You use the ToString method to convert Boolean values to strings. Logická struktura obsahuje dvě ToString přetížení: ToString() metodu bez parametrů a ToString(IFormatProvider) metodu, která obsahuje parametr, který ovládá formátování.The Boolean structure includes two ToString overloads: the parameterless ToString() method and the ToString(IFormatProvider) method, which includes a parameter that controls formatting. Nicméně, protože tento parametr je ignorován, dvě přetížení poskytují identické řetězce.However, because this parameter is ignored, the two overloads produce identical strings. ToString(IFormatProvider) Metoda nepodporuje formátování zohledňující jazykovou verzi.The ToString(IFormatProvider) method does not support culture-sensitive formatting.

Následující příklad znázorňuje formátování pomocí ToString metody.The following example illustrates formatting with the ToString method. Všimněte si, že v příkladu se používá funkce složeného formátování ToString , takže je metoda volána implicitně.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

Vzhledem k tomu, že strukturamůžemítpouzedvěhodnoty,jesnadnépřidatvlastníformátování.BooleanBecause the Boolean structure can have only two values, it is easy to add custom formatting. Pro jednoduché vlastní formátování, ve kterém jsou jiné řetězcové literály nahrazeny "true" a "false", můžete použít libovolnou funkci podmíněného vyhodnocení, kterou váš jazyk podporuje, například podmíněný operátor v C# nebo operátor if v 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. Následující příklad používá tuto techniku k formátování Boolean hodnot jako "Ano" a "ne", nikoli "true" a "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

Pro složitější operace vlastního formátování, včetně formátování zohledňující jazykovou verzi, můžete zavolat String.Format(IFormatProvider, String, Object[]) metodu a ICustomFormatter poskytnout implementaci.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. Následující příklad implementuje ICustomFormatter rozhraní a IFormatProvider k poskytnutí logických řetězců závislých na jazykové verzi pro anglickou (USA), francouzština (Francie) a ruštinu (Rusko) kultur.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': верно

Volitelně můžete použít soubory prostředků k definování logických řetězců specifických pro jazykovou verzi.Optionally, you can use resource files to define culture-specific Boolean strings.

Převod na logické hodnoty a z nichConverting to and from Boolean values

Boolean StrukturaIConvertible implementuje rozhraní.The Boolean structure implements the IConvertible interface. V důsledku toho můžete použít Convert třídu k provádění převodů Boolean mezi hodnotou a jakýmkoli jiným primitivním typem v .NET Framework, Boolean nebo můžete volat explicitní implementace struktury.As a result, you can use the Convert class to perform conversions between a Boolean value and any other primitive type in the .NET Framework, or you can call the Boolean structure's explicit implementations. Převody mezi Boolean a následující typy se však nepodporují, takže odpovídající metody převodu InvalidCastException vyvolávají výjimku:However, conversions between a Boolean and the following types are not supported, so the corresponding conversion methods throw an InvalidCastException exception:

Všechny převody z integrálních nebo plovoucích čísel s plovoucí desetinnou čárkou na logické hodnoty true převádějí nenulové falsehodnoty na a nulové hodnoty na.All conversions from integral or floating-point numbers to Boolean values convert non-zero values to true and zero values to false. Následující příklad znázorňuje toto voláním vybraných přetížení Convert.ToBoolean třídy.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

Při převodu z hodnot s plovoucí desetinnou čárkou na hodnoty Boolean provede metoda převodu přesné porovnání s nulou.When converting from floating-point values to Boolean values, the conversion methods perform an exact comparison with zero. Pokud hodnota s plovoucí desetinnou čárkou ztratí přesnost, výsledek může být neočekávaný.If the floating-point value has lost precision, the result can be unexpected. To je znázorněno v následujícím příkladu, ve kterém Double proměnná, jejíž hodnota by měla být nula, je převedena na logickou hodnotu.This is illustrated in the following example, in which a Double variable whose value should be zero is converted to a Boolean value. Jak ukazuje příklad, výsledkem je true , že opakované přídavky 0,2 mají za následek ztrátu přesnosti.As the example shows, the result is true because repeated additions of 0.2 have resulted in a loss of precision.

Při převodu z typu Boolean na číselné hodnoty se metody Convert převodu třídy převedou true na 1 a 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. Visual Basic převodní funkce se však převádějí true buď na 255 (pro převody na Byte hodnoty), nebo-1 (pro všechny ostatní číselné převody).However, Visual Basic conversion functions convert true to either 255 (for conversions to Byte values) or -1 (for all other numeric conversions). Následující příklad převede true na číselné hodnoty Convert pomocí metody, a v případě Visual Basicho příkladu pomocí vlastního operátoru převodu Visual Basicho jazyka.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)

Pro převody z Boolean na hodnoty řetězce si přečtěte část formátování logických hodnot .For conversions from Boolean to string values, see the Formatting Boolean Values section. Pro převody z řetězců na Boolean hodnoty naleznete v části Analýza logických hodnot .For conversions from strings to Boolean values, see the Parsing Boolean Values section.

Analýza logických hodnotParsing Boolean values

Struktura obsahuje dvě Parse metody statické analýzy a TryParse, které převádějí řetězec na logickou hodnotu. BooleanThe Boolean structure includes two static parsing methods, Parse and TryParse, that convert a string to a Boolean value. Řetězcové vyjádření logické hodnoty je definováno ekvivalenty nerozlišujícími písmeny hodnot TrueString polí a FalseString , které jsou "true" a "false", v uvedeném pořadí.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. Jinými slovy, jediné řetězce, které se analyzují úspěšně, jsou "pravda", "NEPRAVDA", "pravda", "NEPRAVDA" nebo u některých kombinovaných ekvivalentů.In other words, the only strings that parse successfully are "True", "False", "true", "false", or some mixed-case equivalent. Nemůžete úspěšně analyzovat číselné řetězce, například "0" nebo "1".You cannot successfully parse numeric strings such as "0" or "1". Úvodní nebo koncové prázdné znaky se při porovnávání řetězců neberou v úvahu.Leading or trailing white-space characters are not considered when performing the string comparison.

Následující příklad používá Parse metody a TryParse k analýze počtu řetězců.The following example uses the Parse and TryParse methods to parse a number of strings. Všimněte si, že je možné úspěšně analyzovat pouze ekvivalenty "true" a "false" pouze pro velká a malá písmena.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'

Pokud programujete v Visual Basic, můžete použít CBool funkci pro převod řetězcové reprezentace čísla na logickou hodnotu.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" je převeden na falsea řetězcová reprezentace jakékoli nenulové hodnoty je převedena na. true"0" is converted to false, and the string representation of any non-zero value is converted to true. Pokud nechcete programovat v Visual Basic, je nutné před převedením na logickou hodnotu převést číselný řetězec na číslo.If you are not programming in Visual Basic, you must convert your numeric string to a number before converting it to a Boolean. Následující příklad ukazuje to převodem pole celých čísel na logické hodnoty.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

Porovnávání logických hodnotComparing Boolean values

Vzhledem k tomu, že true logické falsehodnoty jsou buď nebo, existuje malý CompareTo důvod k explicitnímu volání metody, která označuje, zda je instance větší než, menší nebo rovna zadané hodnotě.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. Obvykle pro porovnání dvou logických proměnných zavoláte Equals metodu nebo použijete operátor rovnosti vašeho jazyka.Typically, to compare two Boolean variables, you call the Equals method or use your language's equality operator.

Pokud však chcete porovnat logickou proměnnou s literálovou logickou hodnotou true nebo false, není nutné provádět explicitní porovnání, protože výsledkem vyhodnocení logické hodnoty je logická hodnota.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. Například výrazyFor 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.

jsou ekvivalentní, ale druhá je kompaktnější.are equivalent, but the second is more compact. Obě techniky však nabízejí srovnatelný výkon.However, both techniques offer comparable performance.

Práce s logickými hodnotami jako binární hodnotyWorking with Booleans as binary values

Logická hodnota zabírá jeden bajt paměti, jak ukazuje následující C# příklad.A Boolean value occupies one byte of memory, as the following C# example shows. Příklad musí být zkompilován s /unsafe přepínačem.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 nízkého řádu bajtu se používá k reprezentaci své hodnoty.The byte's low-order bit is used to represent its value. Hodnota 1 představuje true; hodnota 0 představuje false.A value of 1 represents true; a value of 0 represents false.

Varování

System.Collections.Specialized.BitVector32 Strukturu lze použít pro práci se sadami logických hodnot.You can use the System.Collections.Specialized.BitVector32 structure to work with sets of Boolean values.

Můžete převést logickou hodnotu na její binární reprezentaci voláním BitConverter.GetBytes(Boolean) metody.You can convert a Boolean value to its binary representation by calling the BitConverter.GetBytes(Boolean) method. Metoda vrací pole bajtů s jediným prvkem.The method returns a byte array with a single element. Chcete-li obnovit logickou hodnotu z binární reprezentace, můžete zavolat BitConverter.ToBoolean(Byte[], Int32) metodu.To restore a Boolean value from its binary representation, you can call the BitConverter.ToBoolean(Byte[], Int32) method.

Následující příklad volá BitConverter.GetBytes metodu pro převod logické hodnoty na její binární reprezentaci a zobrazí jednotlivé bity hodnoty a poté BitConverter.ToBoolean zavolá metodu pro obnovení hodnoty z binární reprezentace.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

Provádění operací s logickými hodnotamiPerforming operations with Boolean values

Tato část ukazuje, jak se v aplikacích používají logické hodnoty.This section illustrates how Boolean values are used in apps. První část popisuje její použití jako příznak.The first section discusses its use as a flag. Druhý ukazuje použití aritmetických operací.The second illustrates its use for arithmetic operations.

Logické hodnoty jako příznakyBoolean values as flags

Logické proměnné se nejčastěji používají jako příznaky, k signalizaci přítomnosti nebo nepřítomnosti nějaké podmínky.Boolean variables are most commonly used as flags, to signal the presence or absence of some condition. Například v String.Compare(String, String, Boolean) metodě je konečnýignoreCase ignoreCase ignoreCaseparametr příznak, který označuje, zda porovnání dvou řetězců rozlišuje velká a malá písmena (is true) nebo rozlišuje velká a malá písmena (is 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). Hodnota příznaku se pak dá vyhodnotit v podmíněném příkazu.The value of the flag can then be evaluated in a conditional statement.

Následující příklad používá jednoduchou konzolovou aplikaci k ilustraci použití logických proměnných jako příznaků.The following example uses a simple console app to illustrate the use of Boolean variables as flags. Aplikace akceptuje parametry příkazového řádku, které umožňují přesměrování výstupu do zadaného souboru ( /f přepínač) a povolení výstupu pro odeslání do zadaného souboru i do konzoly /b (přepínač).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). Aplikace definuje příznak s názvem isRedirected k určení, zda má být výstup odeslán do souboru, a příznak s názvem isBoth k označení, že výstup by měl být odeslán do konzoly.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

Logické hodnoty a aritmetické operaceBooleans and arithmetic operations

Logická hodnota se někdy používá k označení přítomnosti podmínky, která spouští matematický výpočet.A Boolean value is sometimes used to indicate the presence of a condition that triggers a mathematical calculation. Například hasShippingCharge proměnná může sloužit jako příznak označující, zda se mají přidat poplatky za expedici do částky faktury.For example, a hasShippingCharge variable might serve as a flag to indicate whether to add shipping charges to an invoice amount.

Vzhledem k tomu, že false operace s hodnotou nemá žádný vliv na výsledek operace, není nutné převést logickou hodnotu na celočíselnou hodnotu pro použití v matematické operaci.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. Místo toho můžete použít podmíněnou logiku.Instead, you can use conditional logic.

Následující příklad vypočítá množství, které se skládá z mezisoučtu, zpoplatnění expedice a volitelného poplatku za službu.The following example computes an amount that consists of a subtotal, a shipping charge, and an optional service charge. hasServiceCharge Proměnná Určuje, zda je použit poplatek za službu.The hasServiceCharge variable determines whether the service charge is applied. Místo konverze hasServiceCharge na číselnou hodnotu a jejich vynásobení hodnotou poplatku za službu použije tento příklad podmíněný logiku k přidání částky poplatků za službu, pokud je k dispozici.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.

Logické hodnoty a spolupráceBooleans and interop

Zatímco zařazování základních datových typů do modelu COM je obecně jednoduché, Boolean datový typ je výjimka.While marshaling base data types to COM is generally straightforward, the Boolean data type is an exception. MarshalAsAttribute Atribut lze použít pro Boolean zařazení typu do některého z následujících reprezentace:You can apply the MarshalAsAttribute attribute to marshal the Boolean type to any of the following representations:

Typ výčtuEnumeration type Nespravovaný formátUnmanaged format
UnmanagedType.Bool Celočíselná hodnota o velikosti 4 bajt, kde jakákoli nenulová hodnota true představuje a 0 falsepředstavuje.A 4-byte integer value, where any nonzero value represents true and 0 represents false. Toto je výchozí formát Boolean pole ve struktuře a Boolean parametr v voláních vyvolání platformy.This is the default format of a Boolean field in a structure and of a Boolean parameter in platform invoke calls.
UnmanagedType.U1 Hodnota 1 bajt celé číslo, kde 1 představuje true a 0 představuje. falseA 1-byte integer value, where the 1 represents true and 0 represents false.
UnmanagedType.VariantBool Hodnota 2 bajt celé číslo, kde-1 představuje true a 0 představuje. falseA 2-byte integer value, where -1 represents true and 0 represents false. Toto je výchozí formát Boolean parametru v voláních komunikace s objekty com.This is the default format of a Boolean parameter in COM interop calls.

Pole

FalseString FalseString FalseString FalseString

Představuje logickou hodnotu false jako řetězec.Represents the Boolean value false as a string. Toto pole je jen pro čtení.This field is read-only.

TrueString TrueString TrueString TrueString

Představuje logickou hodnotu true jako řetězec.Represents the Boolean value true as a string. Toto pole je jen pro čtení.This field is read-only.

Metody

CompareTo(Boolean) CompareTo(Boolean) CompareTo(Boolean) CompareTo(Boolean)

Porovná tuto instanci se zadaným Boolean objektem a vrátí celé číslo, které určuje jejich vztah mezi sebou.Compares this instance to a specified Boolean object and returns an integer that indicates their relationship to one another.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrátí celé číslo, které určuje jejich vztah mezi sebou.Compares this instance to a specified object and returns an integer that indicates their relationship to one another.

Equals(Boolean) Equals(Boolean) Equals(Boolean) Equals(Boolean)

Vrátí hodnotu, která označuje, zda je tato instance rovna Boolean zadanému objektu.Returns a value indicating whether this instance is equal to a specified Boolean object.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Vrátí kód hash této instance.Returns the hash code for this instance.

GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

Vrátí kód typu pro Boolean typ hodnoty.Returns the type code for the Boolean value type.

Parse(ReadOnlySpan<Char>) Parse(ReadOnlySpan<Char>) Parse(ReadOnlySpan<Char>) Parse(ReadOnlySpan<Char>)
Parse(String) Parse(String) Parse(String) Parse(String)

Převede určenou řetězcovou reprezentaci logické hodnoty na její Boolean ekvivalent.Converts the specified string representation of a logical value to its Boolean equivalent.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

Převede hodnotu této instance na odpovídající řetězcovou reprezentaci (True nebo False).Converts the value of this instance to its equivalent string representation (either "True" or "False").

ToString() ToString() ToString() ToString()

Převede hodnotu této instance na odpovídající řetězcovou reprezentaci (True nebo False).Converts the value of this instance to its equivalent string representation (either "True" or "False").

TryFormat(Span<Char>, Int32) TryFormat(Span<Char>, Int32) TryFormat(Span<Char>, Int32) TryFormat(Span<Char>, Int32)
TryParse(ReadOnlySpan<Char>, Boolean) TryParse(ReadOnlySpan<Char>, Boolean) TryParse(ReadOnlySpan<Char>, Boolean) TryParse(ReadOnlySpan<Char>, Boolean)
TryParse(String, Boolean) TryParse(String, Boolean) TryParse(String, Boolean) TryParse(String, Boolean)

Pokusí se převést zadanou řetězcovou reprezentaci logické hodnoty na její Boolean ekvivalent.Tries to convert the specified string representation of a logical value to its Boolean equivalent. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.A return value indicates whether the conversion succeeded or failed.

Explicitní implementace rozhraní

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

Popis tohoto člena naleznete v tématu ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

Popis tohoto člena naleznete v tématu ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

Tento převod není podporován.This conversion is not supported. Pokus o použití této metody vyvolá InvalidCastExceptionvýjimku.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

Tento převod není podporován.This conversion is not supported. Pokus o použití této metody vyvolá InvalidCastExceptionvýjimku.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

Popis tohoto člena naleznete v tématu ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

Popis tohoto člena naleznete v tématu ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

Popis tohoto člena naleznete v tématu ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

Popis tohoto člena naleznete v tématu ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

Popis tohoto člena naleznete v tématu ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

Popis tohoto člena naleznete v tématu ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

Popis tohoto člena naleznete v tématu ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

Platí pro

Bezpečný přístup z více vláken

Všechny členy tohoto typu jsou zabezpečeny pro přístup z více vláken.All members of this type are thread safe. Členy, které patrně upravují stav instance, ve skutečnosti vrací novou instanci inicializovanou s použitím nové hodnoty.Members that appear to modify instance state actually return a new instance initialized with the new value. Jako u jakéhokoli typu, čtení a zápis do sdílené proměnné, která obsahuje instanci tohoto typu, musí být chráněn zámkem, který zaručí bezpečný přístup z více vláken.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.