Boolean Struct

Definition

Boole (true veya false) değerini temsil eder.Represents a Boolean (true or false) value.

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

Remarks

Boolean bir örnek iki değerden birini içerebilir: trueveya false.A Boolean instance can have either of two values: true, or false.

Boolean yapısı aşağıdaki görevleri destekleyen yöntemler sağlar:The Boolean structure provides methods that support the following tasks:

Aşağıdaki bölümlerde bu görevler ve diğer kullanım ayrıntıları açıklanmaktadır:The following sections explain these tasks and other usage details:

Boole değerlerini biçimlendirmeFormatting Boolean values

Bir Boolean dize temsili, bir true değeri için "true" ya da bir false değeri için "false" değeridir.The string representation of a Boolean is either "True" for a true value or "False" for a false value. Boolean değerin dize temsili salt okunurdur TrueString ve FalseString alanları tarafından tanımlanır.The string representation of a Boolean value is defined by the read-only TrueString and FalseString fields.

Boole değerlerini dizelere dönüştürmek için ToString yöntemini kullanırsınız.You use the ToString method to convert Boolean values to strings. Boolean yapısına iki ToString aşırı yükleme vardır: parametresiz ToString() yöntemi ve biçimlendirmeyi denetleyen bir parametre içeren ToString(IFormatProvider) yöntemi.The Boolean structure includes two ToString overloads: the parameterless ToString() method and the ToString(IFormatProvider) method, which includes a parameter that controls formatting. Ancak, bu parametre yoksayıldı, iki aşırı yükleme aynı dizeleri üretir.However, because this parameter is ignored, the two overloads produce identical strings. ToString(IFormatProvider) yöntemi kültüre duyarlı biçimlendirmeyi desteklemez.The ToString(IFormatProvider) method does not support culture-sensitive formatting.

Aşağıdaki örnekte ToString yöntemiyle biçimlendirme gösterilmektedir.The following example illustrates formatting with the ToString method. Örneğin Bileşik biçimlendirme özelliğini kullandığını unutmayın, bu nedenle ToString yöntemi örtük olarak çağırılır.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

Boolean yapısı yalnızca iki değere sahip olabileceğinden, özel biçimlendirme eklemek kolaydır.Because the Boolean structure can have only two values, it is easy to add custom formatting. Diğer dize değişmez değerlerinin "true" ve "false" için yerine geçen basit özel biçimlendirme için, diliniz tarafından desteklenen koşullu bir değerlendirme özelliğini C# veya Visual Basic içindeki koşul işlecini kullanabilirsiniz. If operatorFor 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. Aşağıdaki örnek, Boolean değerlerini "true" ve "false" yerine "Yes" ve "No" olarak biçimlendirmek için bu tekniği kullanır.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

Kültüre duyarlı biçimlendirme de dahil olmak üzere daha karmaşık özel biçimlendirme işlemleri için, String.Format(IFormatProvider, String, Object[]) yöntemini çağırabilir ve ICustomFormatter bir uygulama sağlayabilirsiniz.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. Aşağıdaki örnek, Ingilizce (Birleşik Devletler), Fransızca (Fransa) ve Rusça (Rusya) kültürleri için kültüre duyarlı Boolean dizeler sağlamak üzere ICustomFormatter ve IFormatProvider arabirimlerini uygular.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': верно

İsteğe bağlı olarak, kültüre özgü Boole dizelerini tanımlamak için kaynak dosyalarını kullanabilirsiniz.Optionally, you can use resource files to define culture-specific Boolean strings.

Boole değerlerinden ve bu değerlere dönüştürmeConverting to and from Boolean values

Boolean yapısı IConvertible arabirimini uygular.The Boolean structure implements the IConvertible interface. Sonuç olarak, .NET 'teki bir Boolean değeri ile diğer temel tür arasında dönüştürmeler gerçekleştirmek için Convert sınıfını kullanabilir veya Boolean yapısının açık uygulamalarını çağırabilirsiniz.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. Ancak, Boolean ve aşağıdaki türler arasındaki dönüştürmeler desteklenmez, bu nedenle karşılık gelen dönüştürme yöntemleri bir InvalidCastException özel durumu oluşturur:However, conversions between a Boolean and the following types are not supported, so the corresponding conversion methods throw an InvalidCastException exception:

İntegral veya kayan noktalı sayıların Boole değerlerine kadar olan tüm dönüştürmeler, sıfır olmayan değerleri true ve sıfır değerlerine falsedönüştürür.All conversions from integral or floating-point numbers to Boolean values convert non-zero values to true and zero values to false. Aşağıdaki örnek, Convert.ToBoolean sınıfının seçili yüklerini çağırarak bunu gösterir.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

Kayan nokta değerlerinden Boole değerlerine dönüştürme yaparken, dönüştürme yöntemleri sıfır ile tam bir karşılaştırma gerçekleştirir.When converting from floating-point values to Boolean values, the conversion methods perform an exact comparison with zero. Kayan nokta değerinin doğruluğu kayıpsa, sonuç beklenmedik olabilir.If the floating-point value has lost precision, the result can be unexpected. Bu, değeri sıfır olan bir Double değişkenin Boole değerine dönüştürülmesi için aşağıdaki örnekte gösterilmiştir.This is illustrated in the following example, in which a Double variable whose value should be zero is converted to a Boolean value. Örnekte gösterildiği gibi, yinelenen 0,2 eklemeleri duyarlık kaybına neden olduğundan sonuç true.As the example shows, the result is true because repeated additions of 0.2 have resulted in a loss of precision.

Boolean değerinden sayısal değerlere dönüştürme yaparken, Convert sınıfının dönüştürme yöntemleri true 1 ' e ve false 0 ' a dönüştürür.When converting from Boolean to numeric values, the conversion methods of the Convert class convert true to 1 and false to 0. Ancak Visual Basic dönüştürme işlevleri true 255 (Byte değerlere dönüşümler için) ya da-1 (diğer tüm sayısal dönüştürmeler için) olarak dönüştürür.However, Visual Basic conversion functions convert true to either 255 (for conversions to Byte values) or -1 (for all other numeric conversions). Aşağıdaki örnek, Convert bir yöntemi kullanarak true sayısal değerlere dönüştürür ve Visual Basic dilinin kendi dönüştürme işlecini kullanarak Visual Basic örneği söz konusu olduğunda.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)

Boolean dize değerlerine dönüştürme için, Boole değerlerini biçimlendirme bölümüne bakın.For conversions from Boolean to string values, see the Formatting Boolean Values section. Dizelerdeki Boolean değerlere dönüşümler için, Boole değerlerini ayrıştırma bölümüne bakın.For conversions from strings to Boolean values, see the Parsing Boolean Values section.

Boole değerlerini ayrıştırmaParsing Boolean values

Boolean yapısı iki statik ayrıştırma yöntemi içerir, Parse ve TryParse, bir dizeyi Boole değerine dönüştürür.The Boolean structure includes two static parsing methods, Parse and TryParse, that convert a string to a Boolean value. Boole değerinin dize temsili, sırasıyla "true" ve "false" olan TrueString ve FalseString alanları değerlerinin büyük/küçük harf duyarsız eşdeğerlerine göre tanımlanır.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. Diğer bir deyişle, başarıyla ayrıştı olan dizeler "true", "false", "true", "false" veya bazı karışık Case eşdeğerini olur.In other words, the only strings that parse successfully are "True", "False", "true", "false", or some mixed-case equivalent. "0" veya "1" gibi sayısal dizeleri başarıyla ayrıştıramazsınız.You cannot successfully parse numeric strings such as "0" or "1". Dize karşılaştırması gerçekleştirilirken baştaki veya sondaki boşluk karakterleri dikkate alınmamalıdır.Leading or trailing white-space characters are not considered when performing the string comparison.

Aşağıdaki örnek, bir dizi dizeyi ayrıştırmak için Parse ve TryParse yöntemlerini kullanır.The following example uses the Parse and TryParse methods to parse a number of strings. "True" ve "false" değerlerinin yalnızca büyük/küçük harf duyarsız eşdeğerleri başarıyla ayrıştırılabileceğini unutmayın.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'

Visual Basic ' de programlıyorsanız, bir sayının dize gösterimini bir Boolean değere dönüştürmek için CBool işlevini kullanabilirsiniz.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" falsedönüştürülür ve sıfır olmayan bir değerin dize temsili truedönüştürülür."0" is converted to false, and the string representation of any non-zero value is converted to true. Visual Basic ' de programlıyorsanız, sayısal dizeyi Boole değerine dönüştürmeden önce bir sayıya dönüştürmeniz gerekir.If you are not programming in Visual Basic, you must convert your numeric string to a number before converting it to a Boolean. Aşağıdaki örnek, bir tamsayı dizisini Boole değerlerine dönüştürerek bunu gösterir.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

Boole değerlerini karşılaştırmaComparing Boolean values

Boolean değerleri true veya falseolduğundan, bir örneğin belirtilen bir değerden daha büyük veya bu değere eşit olup olmadığını gösteren CompareTo yöntemini açıkça çağırmak için çok az neden vardır.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. Genellikle, iki Boolean değişkenini karşılaştırmak için Equals yöntemini çağırır veya dilinizin eşitlik işlecini kullanırsınız.Typically, to compare two Boolean variables, you call the Equals method or use your language's equality operator.

Ancak, bir Boolean değişkenini sabit değer Boolean değeri true veya falseile karşılaştırmak istediğinizde, bir Boolean değeri değerlendirme sonucu Boole değeri olduğundan açık bir karşılaştırma yapmak gerekli değildir.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. Örneğin, ifadelerFor example, the expressions

if (booleanValue) {
If booleanValue Then

veand

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.

eşdeğerdir, ancak ikincisi daha küçük.are equivalent, but the second is more compact. Ancak, her iki teknik de karşılaştırılabilir performans sunar.However, both techniques offer comparable performance.

İkili değerler olarak Boole 'lar ile çalışmaWorking with Booleans as binary values

Aşağıdaki C# örnekte gösterildiği gibi bir Boole değeri bir bellek baytını kaplar.A Boolean value occupies one byte of memory, as the following C# example shows. Örnek, /unsafe anahtarıyla derlenmelidir.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

Baytın düşük sıra biti, değerini temsil etmek için kullanılır.The byte's low-order bit is used to represent its value. 1 değeri truetemsil eder; 0 değeri falsetemsil eder.A value of 1 represents true; a value of 0 represents false.

Warning

System.Collections.Specialized.BitVector32 yapısını, Boolean değer kümeleriyle çalışmak için kullanabilirsiniz.You can use the System.Collections.Specialized.BitVector32 structure to work with sets of Boolean values.

BitConverter.GetBytes(Boolean) yöntemini çağırarak bir Boole değerini ikili gösterimine dönüştürebilirsiniz.You can convert a Boolean value to its binary representation by calling the BitConverter.GetBytes(Boolean) method. Yöntemi, tek bir öğesi olan bir bayt dizisi döndürür.The method returns a byte array with a single element. İkili gösteriminden bir Boole değeri geri yüklemek için BitConverter.ToBoolean(Byte[], Int32) yöntemini çağırabilirsiniz.To restore a Boolean value from its binary representation, you can call the BitConverter.ToBoolean(Byte[], Int32) method.

Aşağıdaki örnek, bir Boolean değeri ikili gösterimine dönüştürmek için BitConverter.GetBytes yöntemini çağırır ve değerin tek bir bitini görüntüler ve ardından değeri ikili gösteriminden geri yüklemek için BitConverter.ToBoolean yöntemini çağırır.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

Boole değerleriyle işlem gerçekleştirmePerforming operations with Boolean values

Bu bölüm, uygulamalarda Boole değerlerinin nasıl kullanıldığını gösterir.This section illustrates how Boolean values are used in apps. İlk bölüm, bir bayrak olarak kullanımını açıklar.The first section discusses its use as a flag. İkincisi, aritmetik işlemler için kullanımını gösterir.The second illustrates its use for arithmetic operations.

Bayraklar olarak Boole değerleriBoolean values as flags

Boole değişkenleri, bir koşulun varlığını veya yokluğunu bildirmek için en yaygın olarak bayraklar olarak kullanılır.Boolean variables are most commonly used as flags, to signal the presence or absence of some condition. Örneğin, String.Compare(String, String, Boolean) yönteminde, ignoreCaseson parametresi, iki dizenin karşılaştırmasının büyük/küçük harf duyarsız mi (ignoreCase true) yoksa büyük/küçük harfe duyarlı mi (ignoreCase false) olduğunu gösteren bir bayraktır.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). Daha sonra bayrağın değeri bir koşullu ifadede değerlendirilebilir.The value of the flag can then be evaluated in a conditional statement.

Aşağıdaki örnek, Boolean değişkenlerinin bayrak olarak kullanımını göstermek için basit bir konsol uygulaması kullanır.The following example uses a simple console app to illustrate the use of Boolean variables as flags. Uygulama, çıkışın belirtilen bir dosyaya (/f anahtarı) yönlendirilmesini sağlayan ve çıktının hem belirtilen bir dosyaya hem de konsola (/b anahtarı) gönderilmesini sağlayan komut satırı parametrelerini kabul eder.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). Uygulama, çıktının bir dosyaya gönderilip gönderilmeyeceğini göstermek için isRedirected adlı bir bayrak ve çıktının konsola gönderilmesi gerektiğini belirtmek için isBoth adlı bir bayrak tanımlar.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

Boole değerleri ve aritmetik işlemlerBooleans and arithmetic operations

Boole değeri bazen bir matematiksel hesaplamayı tetikleyen koşulun varlığını göstermek için kullanılır.A Boolean value is sometimes used to indicate the presence of a condition that triggers a mathematical calculation. Örneğin, bir hasShippingCharge değişken, bir fatura tutarına sevkiyat ücretleri eklenip eklenmeyeceğini belirten bir bayrak olarak işlev gösterebilir.For example, a hasShippingCharge variable might serve as a flag to indicate whether to add shipping charges to an invoice amount.

false değeri olan bir işlemin bir işlemin sonucu üzerinde hiçbir etkisi olmadığından, Boole değerini matematik işleminde kullanılacak bir integral değere dönüştürmek gerekli değildir.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. Bunun yerine, koşullu mantığı kullanabilirsiniz.Instead, you can use conditional logic.

Aşağıdaki örnek, bir alt toplam, bir sevkiyat ücreti ve isteğe bağlı bir hizmet ücretinden oluşan bir miktarı hesaplar.The following example computes an amount that consists of a subtotal, a shipping charge, and an optional service charge. hasServiceCharge değişkeni, hizmet ücretinin uygulanıp uygulanmadığı belirler.The hasServiceCharge variable determines whether the service charge is applied. hasServiceCharge, sayısal bir değere dönüştürmek ve hizmet ücreti miktarına göre çarpılması yerine, uygunsa hizmet ücreti miktarını eklemek için koşullu mantığı kullanır.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.

Boole değerleri ve birlikte çalışmaBooleans and interop

Temel veri türlerini COM 'a hazırlama genellikle basittir, Boolean veri türü bir istisnadır.While marshaling base data types to COM is generally straightforward, the Boolean data type is an exception. Aşağıdaki gösterimlerden herhangi birine Boolean türünü sıralamak için MarshalAsAttribute özniteliğini uygulayabilirsiniz:You can apply the MarshalAsAttribute attribute to marshal the Boolean type to any of the following representations:

Sabit listesi türüEnumeration type Yönetilmeyen biçimUnmanaged format
UnmanagedType.Bool Sıfır dışında bir değerin true gösterdiği ve 0 ' ı gösterdiği 4 baytlık bir tamsayı değeri false.A 4-byte integer value, where any nonzero value represents true and 0 represents false. Bu, bir yapıdaki Boolean alanının ve platform çağırma çağrılarında Boolean parametresinin varsayılan biçimidir.This is the default format of a Boolean field in a structure and of a Boolean parameter in platform invoke calls.
UnmanagedType.U1 1 ' in true gösterdiği ve 0 ' ı temsil eden bir 1 baytlık tamsayı değeri falsetemsil eder.A 1-byte integer value, where the 1 represents true and 0 represents false.
UnmanagedType.VariantBool 2 baytlık bir tamsayı değeri; burada-1 true ve 0 ' ı falsetemsil eder.A 2-byte integer value, where -1 represents true and 0 represents false. Bu, COM birlikte çalışma çağrılarında bir Boolean parametresinin varsayılan biçimidir.This is the default format of a Boolean parameter in COM interop calls.

Fields

FalseString

Boole değerini bir dize olarak false temsil eder.Represents the Boolean value false as a string. Bu alan salt okunur durumdadır.This field is read-only.

TrueString

Boole değerini bir dize olarak true temsil eder.Represents the Boolean value true as a string. Bu alan salt okunur durumdadır.This field is read-only.

Methods

CompareTo(Boolean)

Bu örneği belirtilen bir Boolean nesne ile karşılaştırır ve bir ile ilişkilerini gösteren bir tamsayı döndürür.Compares this instance to a specified Boolean object and returns an integer that indicates their relationship to one another.

CompareTo(Object)

Bu örneği belirtilen bir nesneyle karşılaştırır ve birbiriyle ilişkilerini gösteren bir tamsayı döndürür.Compares this instance to a specified object and returns an integer that indicates their relationship to one another.

Equals(Boolean)

Bu örneğin belirtilen bir Boolean nesnesine eşit olup olmadığını gösteren bir değer döndürür.Returns a value indicating whether this instance is equal to a specified Boolean object.

Equals(Object)

Bu örneğin, belirtilen bir nesneye eşit olup olmadığını gösteren bir değeri döndürür.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode()

Bu örneğe ilişkin karma kodu döndürür.Returns the hash code for this instance.

GetTypeCode()

Boolean değer türü için tür kodunu döndürür.Returns the type code for the Boolean value type.

Parse(ReadOnlySpan<Char>)

Bir mantıksal değerin belirtilen span gösterimini Boolean eşdeğerine dönüştürür.Converts the specified span representation of a logical value to its Boolean equivalent.

Parse(String)

Bir mantıksal değerin belirtilen dize temsilini Boolean eşdeğerine dönüştürür.Converts the specified string representation of a logical value to its Boolean equivalent.

ToString()

Bu örneğin değerini eşdeğer dize gösterimine ("Doğru" veya "Yanlış") dönüştürür.Converts the value of this instance to its equivalent string representation (either "True" or "False").

ToString(IFormatProvider)

Bu örneğin değerini eşdeğer dize gösterimine ("Doğru" veya "Yanlış") dönüştürür.Converts the value of this instance to its equivalent string representation (either "True" or "False").

TryFormat(Span<Char>, Int32)

Geçerli Boole örneğinin değerini, belirtilen karakter aralığında biçimlendirmeye çalışır.Tries to format the value of the current boolean instance into the provided span of characters.

TryParse(ReadOnlySpan<Char>, Boolean)

Bir mantıksal değerin belirtilen span gösterimini Boolean eşdeğerine dönüştürmeye çalışır.Tries to convert the specified span representation of a logical value to its Boolean equivalent.

TryParse(String, Boolean)

Bir mantıksal değerin belirtilen dize temsilini Boolean eşdeğerine dönüştürmeye çalışır.Tries to convert the specified string representation of a logical value to its Boolean equivalent.

Explicit Interface Implementations

IComparable.CompareTo(Object)

Mevcut örneği aynı türdeki başka bir nesne ile karşılaştırır ve geçerli örneğin, diğer nesneyle aynı sıralama düzeni konumunda mı olduğunu, önünde mi olduğunu, yoksa arkasında mı olduğunu belirten bir tamsayı döndürür.Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object.

IConvertible.GetTypeCode()

Bu örnek için TypeCode döndürür.Returns the TypeCode for this instance.

IConvertible.ToBoolean(IFormatProvider)

Bu üyenin açıklaması için bkz. ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Bu üyenin açıklaması için bkz. ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Bu dönüşüm desteklenmiyor.This conversion is not supported. Bu yöntemi kullanma girişimi bir InvalidCastExceptionoluşturur.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDateTime(IFormatProvider)

Bu dönüşüm desteklenmiyor.This conversion is not supported. Bu yöntemi kullanma girişimi bir InvalidCastExceptionoluşturur.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider)

Bu üyenin açıklaması için bkz. ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Bu üyenin açıklaması için bkz. ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Bu üyenin açıklaması için bkz. ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Bu üyenin açıklaması için bkz. ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Bu üyenin açıklaması için bkz. ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Bu üyenin açıklaması için bkz. ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Bu üyenin açıklaması için bkz. ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider)

Bu örneğin değerini, belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak eşdeğer bir dizeye dönüştürür.Converts the value of this instance to an equivalent string using the specified culture-specific formatting information.

IConvertible.ToType(Type, IFormatProvider)

Bu üyenin açıklaması için bkz. ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Bu üyenin açıklaması için bkz. ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Bu üyenin açıklaması için bkz. ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Bu üyenin açıklaması için bkz. ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

Applies to

Thread Safety

Bu türün tüm üyeleri iş parçacığı güvenlidir.All members of this type are thread safe. Örneğin durumunu değiştirmek için görüntülenen üyeler, gerçekte yeni değer ile başlatılan yeni bir örneği döndürür.Members that appear to modify instance state actually return a new instance initialized with the new value. Diğer türlerde olduğu gibi, bu türün örneğini içeren paylaşılan değişkenini okuma ve yazma, iş parçacığı güvenliğini sağlamak için bir kilit tarafından korunmalıdır.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.