Boolean Boolean Boolean Boolean Struct

정의

부울(true 또는 false) 값을 나타냅니다. Represents a Boolean (true or false) value.

public value class Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
[System.Runtime.InteropServices.ComVisible(true)]
[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)
상속
특성
ComVisibleAttribute SerializableAttribute
구현

설명

A Boolean 인스턴스 두 값 중 하나를 가질 수 있습니다: true, 또는 false합니다.A Boolean instance can have either of two values: true, or false.

Boolean 구조는 다음과 같은 작업을 지 원하는 메서드를 제공 합니다.The Boolean structure provides methods that support the following tasks:

다음 섹션에서는 이러한 태스크 및 기타 사용 현황 세부 정보를 설명합니다.The following sections explain these tasks and other usage details:

부울 값의 서식 지정 Formatting Boolean values
부울 값 사이의 변환 Converting to and from Boolean values
부울 값을 구문 분석 Parsing Boolean values
부울 값 비교 Comparing Boolean values
이진 값으로 부울을 사용 하 여 작동합니다. Working with Booleans as binary values
부울 값을 사용 하 여 작업을 수행합니다. Performing operations with Boolean values
않음은 Booleans 및 InteropBooleans and Interop

부울 값의 서식 지정Formatting Boolean values

문자열 표현을 Boolean 은 "True"에 대 한는 true 값 또는 "False"에 대 한는 false 값.The string representation of a Boolean is either "True" for a true value or "False" for a false value. 문자열 표현 된 Boolean 값의 읽기 전용으로 정의 됩니다 TrueStringFalseString 필드입니다.The string representation of a Boolean value is defined by the read-only TrueString and FalseString fields.

사용 된 ToString 부울 값을 문자열로 변환 하는 방법입니다.You use the ToString method to convert Boolean values to strings. 두 부울 구조 포함 ToString 오버 로드: 매개 변수가 없는 ToString() 메서드 및 ToString(IFormatProvider) 서식 지정을 제어 하는 매개 변수를 포함 하는 메서드.The Boolean structure includes two ToString overloads: the parameterless ToString() method and the ToString(IFormatProvider) method, which includes a parameter that controls formatting. 그러나이 매개 변수는 무시 되므로 두 오버 로드는 동일한 문자열을 생성 합니다.However, because this parameter is ignored, the two overloads produce identical strings. ToString(IFormatProvider) 메서드 문화권 구분 서식 지정을 지원 하지 않습니다.The ToString(IFormatProvider) method does not support culture-sensitive formatting.

다음 예제를 사용 하 여 서식 지정을 ToString 메서드.The following example illustrates formatting with the ToString method. 예제를 사용 하는 참고 합니다 복합 서식 지정 기능을 하므로 ToString 메서드는 암시적으로 호출 됩니다.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 구조는 두 개의 값을 가질 수, 사용자 지정 서식 지정을 추가 하기 쉽습니다.Because the Boolean structure can have only two values, it is easy to add custom formatting. 간단한 사용자 지정 서식 지정을 위해 다른 문자열 리터럴 "True" 및 "False"에 대 한 대체는 같은 언어를 지 원하는 모든 조건부 평가 기능을 사용할 수 있습니다 합니다 조건부 연산자 C# 또는 합니다 경우 연산자 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. 다음 예제에서는이 기술을 사용 하 여 서식을 지정 하려면 Boolean 값 "Yes" 및 "No" 대신 "True" 및 "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

더 복잡 한 사용자 지정 서식 지정 작업에 대 한 문화권 구분 서식 지정을 포함 하 여 호출할 수 있습니다는 String.Format(IFormatProvider, String, Object[]) 메서드를 제공 하 고는 ICustomFormatter 구현 합니다.For more complex custom formatting operations, including culture-sensitive formatting, you can call the String.Format(IFormatProvider, String, Object[]) method and provide an ICustomFormatter implementation. 다음 예에서는 구현 하는 ICustomFormatterIFormatProvider 영어 (미국), 프랑스어 (프랑스) 및 러시아어 (러시아) 문화권에 대 한 문화권별 부울 문자열을 제공 하는 인터페이스입니다.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': верно

사용할 수 있습니다 리소스 파일 문화권별 부울 문자열을 정의 합니다.Optionally, you can use resource files to define culture-specific Boolean strings.

부울 값 사이의 변환Converting to and from Boolean values

합니다 Boolean 구현 구조체는 IConvertible 인터페이스입니다.The Boolean structure implements the IConvertible interface. 결과적으로 사용할 수 있습니다는 Convert 간에 변환을 수행 하는 클래스를 Boolean 값과.NET Framework의 다른 기본 형식을 호출할 수는 Boolean 구조체의 명시적 구현입니다.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. 그러나 간의 변환을 Boolean 및 다음 종류는 지원 되지 않으므로 해당 변환 메서드까지 throw는 InvalidCastException 예외:However, conversions between a Boolean and the following types are not supported, so the corresponding conversion methods throw an InvalidCastException exception:

부울 값으로 모든 변환은 정수 계열 또는 부동 소수점 숫자에서 0이 아닌 값으로 변환 true 및 0 값을 false입니다.All conversions from integral or floating-point numbers to Boolean values convert non-zero values to true and zero values to false. 다음 예제에서는 선택한 오버 로드를 호출 하 여이 설명 합니다 Convert.ToBoolean 클래스입니다.The following example illustrates this by calling selected overloads of the Convert.ToBoolean class.

using System;

public class Example
{
   public static void Main()
   {
      Byte byteValue = 12;
      Console.WriteLine(Convert.ToBoolean(byteValue));
      Byte byteValue2 = 0;
      Console.WriteLine(Convert.ToBoolean(byteValue2));
      int intValue = -16345;
      Console.WriteLine(Convert.ToBoolean(intValue));
      long longValue = 945;
      Console.WriteLine(Convert.ToBoolean(longValue));
      SByte sbyteValue = -12;
      Console.WriteLine(Convert.ToBoolean(sbyteValue));
      double dblValue = 0;
      Console.WriteLine(Convert.ToBoolean(dblValue));
      float sngValue = .0001f;
      Console.WriteLine(Convert.ToBoolean(sngValue));
   }
}
// The example displays the following output:
//       True
//       False
//       True
//       True
//       True
//       False
//       True
Module Example
   Public Sub Main()
      Dim byteValue As Byte = 12
      Console.WriteLine(Convert.ToBoolean(byteValue))
      Dim byteValue2 As Byte = 0
      Console.WriteLine(Convert.ToBoolean(byteValue2))
      Dim intValue As Integer = -16345
      Console.WriteLine(Convert.ToBoolean(intValue))
      Dim longValue As Long = 945
      Console.WriteLine(Convert.ToBoolean(longValue))
      Dim sbyteValue As SByte = -12
      Console.WriteLine(Convert.ToBoolean(sbyteValue))
      Dim dblValue As Double = 0
      Console.WriteLine(Convert.ToBoolean(dblValue))
      Dim sngValue As Single = .0001
      Console.WriteLine(Convert.ToBoolean(sngValue))
   End Sub
End Module
' The example displays the following output:
'       True
'       False
'       True
'       True
'       True
'       False
'       True

부동 소수점 값에서 부울 값으로 변환할 때 변환 메서드 0 사용 하 여 정확한 비교를 수행 합니다.When converting from floating-point values to Boolean values, the conversion methods perform an exact comparison with zero. 부동 소수점 값에 전체 자릿수 손실 결과 예상 수 없습니다.If the floating-point value has lost precision, the result can be unexpected. 이는 다음 예제에서는 나와 Double 해당 값은 0 이어야 하는 변수에 부울 값으로 변환 됩니다.This is illustrated in the following example, in which a Double variable whose value should be zero is converted to a Boolean value. 결과 위의 예제와 같이 true 0.2 추가 전체 자릿수 손실이 발생 했을 반복 하기 때문에 있습니다.As the example shows, the result is true because repeated additions of 0.2 have resulted in a loss of precision.

부울의 변환 메서드는 숫자 값에서 변환할 때 합니다 Convert 클래스 변환 true 1 및 false 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 변환 함수 변환 true 하거나 255 (변환을 Byte 값) 또는-1 (다른 모든 숫자 변환의).However, Visual Basic conversion functions convert true to either 255 (for conversions to Byte values) or -1 (for all other numeric conversions). 다음 예제에서는 변환 true 을 사용 하 여 숫자 값을 Convert 메서드 및 Visual Basic 예제에서는 Visual Basic 언어의 자체 변환 연산자를 사용 하 여의 경우.The following example converts true to numeric values by using a Convert method, and, in the case of the Visual Basic example, by using the Visual Basic language's own conversion operator.

using System;

public class Example
{
   public static void Main()
   {
      bool flag = true;
      
      byte byteValue;   
      byteValue = Convert.ToByte(flag);
      Console.WriteLine("{0} -> {1}", flag, byteValue);         
      
      sbyte sbyteValue;
      sbyteValue = Convert.ToSByte(flag);
      Console.WriteLine("{0} -> {1}", flag, sbyteValue);         

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

      int intValue;
      intValue = Convert.ToInt32(flag);
      Console.WriteLine("{0} -> {1}", flag, intValue);         
   }
}
// The example displays the following output:
//       True -> 1
//       True -> 1
//       True -> 1
//       True -> 1
Module Example
   Public Sub Main()
      Dim flag As Boolean = true
      
      Dim byteValue As Byte   
      byteValue = Convert.ToByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, byteValue, 
                                            byteValue.GetType().Name)         
      byteValue = CByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, byteValue, 
                                            byteValue.GetType().Name)         
      
      Dim sbyteValue As SByte
      sbyteValue = Convert.ToSByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue, 
                                            sbyteValue.GetType().Name)         
      sbyteValue = CSByte(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue, 
                                            sbyteValue.GetType().Name)         

      Dim dblValue As Double
      dblValue = Convert.ToDouble(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, dblValue, 
                                            dblValue.GetType().Name)         
      dblValue = CDbl(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, dblValue, 
                                            dblValue.GetType().Name)         

      Dim intValue As Integer
      intValue = Convert.ToInt32(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, intValue, 
                                            intValue.GetType().Name)         
      intValue = CInt(flag)
      Console.WriteLine("{0} -> {1} ({2})", flag, intValue, 
                                            intValue.GetType().Name)         
   End Sub
End Module
' The example displays the following output:
'       True -> 1 (Byte)
'       True -> 255 (Byte)
'       True -> 1 (SByte)
'       True -> -1 (SByte)
'       True -> 1 (Double)
'       True -> -1 (Double)
'       True -> 1 (Int32)
'       True -> -1 (Int32)

변환에 대 한 Boolean 문자열 값을 참조 합니다 부울 값 서식 지정 섹션입니다.For conversions from Boolean to string values, see the Formatting Boolean Values section. 문자열에서 변환에 대 한 Boolean 값을 참조 합니다 부울 값을 구문 분석 섹션입니다.For conversions from strings to Boolean values, see the Parsing Boolean Values section.

부울 값을 구문 분석Parsing Boolean values

합니다 Boolean 구조체에는 두 개의 정적 구문 분석 메서드를 포함 ParseTryParse, 문자열을 부울 값을 변환 하는 합니다.The Boolean structure includes two static parsing methods, Parse and TryParse, that convert a string to a Boolean value. 부울 값의 문자열 표현을 값의 해당 하는 대/소문자가 정의한 합니다 TrueStringFalseString 필드를 "True" 및 "False", 각각.The string representation of a Boolean value is defined by the case-insensitive equivalents of the values of the TrueString and FalseString fields, which are "True" and "False", respectively. 즉, 성공적으로 구문 분석 하는 문자열만 "True", "False", "true", "false" 또는 일부 소문자에 해당 됩니다.In other words, the only strings that parse successfully are "True", "False", "true", "false", or some mixed-case equivalent. 성공적으로 "0" 또는 "1"와 같은 숫자 문자열을 구문 분석할 수 없습니다. 있습니다.You cannot successfully parse numeric strings such as "0" or "1". 문자열 비교를 수행 하는 경우에 선행 또는 후행 공백 문자 간주 되지 않습니다.Leading or trailing white-space characters are not considered when performing the string comparison.

다음 예제에서는 합니다 ParseTryParse 많은 문자열을 구문 분석 하는 방법입니다.The following example uses the Parse and TryParse methods to parse a number of strings. "True" 및 "False"의 해당 항목에 대/소문자 구분을 성공적으로 구문 분석할 수는 note 합니다.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의 프로그래밍 하는 경우 사용할 수는 CBool 부울 값으로 숫자의 문자열 표현으로 변환 하는 함수입니다.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"으로 변환할 false를 0이 아닌 모든 값의 문자열 표현으로 변환 됩니다 true합니다."0" is converted to false, and the string representation of any non-zero value is converted to true. 하지를 프로그래밍 하는 Visual Basic의 경우 부울으로 변환 하기 전에 숫자 문자열을 숫자로 변환 해야 합니다.If you are not programming in Visual Basic, you must convert your numeric string to a number before converting it to a Boolean. 다음 예제에서는 정수의 배열을 부울 값으로 변환 하 여이 설명 합니다.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

부울 값 비교Comparing Boolean values

부울 값 중 하나 이므로 true 또는 false를 명시적으로 호출 이유가 CompareTo 인지 여부를 나타내는 인스턴스 보다 큼, 보다 작음, 메서드 또는 지정된 된 값 같음.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. 일반적으로 두 개의 부울 변수를 비교 하려면 호출를 Equals 메서드 또는 언어의 같음 연산자를 사용 합니다.Typically, to compare two Boolean variables, you call the Equals method or use your language's equality operator.

그러나 하려는 경우 부울 리터럴 값을 사용 하 여 부울 변수 비교 true 또는 false,이 아니므로 명시적 비교를 수행 하는 데 필요한 부울 값을 평가 하는 결과 해당 부울 값입니다.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. 예를 들어 식For example, the expressions

if (booleanValue) {
If booleanValue Then

를 갖는and

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.

동일 하지만 두 번째는 간결 합니다.are equivalent, but the second is more compact. 그러나 두 기법 모두 비슷한 성능을 제공합니다.However, both techniques offer comparable performance.

이진 값으로 부울을 사용 하 여 작동합니다.Working with Booleans as binary values

다음 C# 예제와 같이 1 바이트의 메모리를 차지 하는 부울 값을 합니다.A Boolean value occupies one byte of memory, as the following C# example shows. 예제를 사용 하 여 컴파일해야 합니다 /unsafe 전환 합니다.The example must be compiled with the /unsafe switch.

using System;

public struct BoolStruct
{
   public bool flag1;
   public bool flag2;
   public bool flag3;
   public bool flag4;
   public bool flag5;
}

public class Example
{
   public static void Main()
   {
      unsafe {
         BoolStruct b = new BoolStruct();
         bool* addr = (bool*) &b;
         Console.WriteLine("Size of BoolStruct: {0}", sizeof(BoolStruct));
         Console.WriteLine("Field offsets:");
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag1 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag2 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag3 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag4 - addr);
         Console.WriteLine("   flag1: {0}", (bool*) &b.flag5 - addr);
      }
   }
}
// The example displays the following output:
//       Size of BoolStruct: 5
//       Field offsets:
//          flag1: 0
//          flag1: 1
//          flag1: 2
//          flag1: 3
//          flag1: 4

바이트의 낮은 비트는 해당 값을 나타내는 데 사용 됩니다.The byte's low-order bit is used to represent its value. 값이 1 나타냅니다 true0 나타냅니다. 값 false합니다.A value of 1 represents true; a value of 0 represents false.

경고

사용할 수는 System.Collections.Specialized.BitVector32 부울 값의 집합으로 작업 하는 구조입니다.You can use the System.Collections.Specialized.BitVector32 structure to work with sets of Boolean values.

호출 하 여 부울 값을 이진 표현으로 변환할 수 있습니다는 BitConverter.GetBytes(Boolean) 메서드.You can convert a Boolean value to its binary representation by calling the BitConverter.GetBytes(Boolean) method. 메서드는 단일 요소를 사용 하 여 바이트 배열을 반환 합니다.The method returns a byte array with a single element. 부울 값을 이진 표현에서 복원 하려면 호출할 수 있습니다는 BitConverter.ToBoolean(Byte[], Int32) 메서드.To restore a Boolean value from its binary representation, you can call the BitConverter.ToBoolean(Byte[], Int32) method.

다음 예제에서는 합니다 BitConverter.GetBytes 해당 이진 표현 및 표시 값 및 호출의 개별 비트에 부울 값을 변환 하는 메서드는 BitConverter.ToBoolean 이진 표현에서 값을 복원 하는 방법입니다.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

부울 값을 사용 하 여 작업을 수행합니다.Performing operations with Boolean values

이 섹션에서는 어떻게 부울 값을 보여 줍니다. 앱에 사용 됩니다.This section illustrates how Boolean values are used in apps. 첫 번째 섹션에는 용도 플래그를 설명합니다.The first section discusses its use as a flag. 두 번째 산술 연산에 대 한 용도를 보여 줍니다.The second illustrates its use for arithmetic operations.

부울 플래그 값Boolean values as flags

부울 변수 상황의 유무를 알리기 위해 플래그로, 가장 자주 사용 됩니다.Boolean variables are most commonly used as flags, to signal the presence or absence of some condition. 예를 들어, 합니다 String.Compare(String, String, Boolean) 메서드를 마지막 매개 ignoreCase, 두 문자열의 비교는 대/소문자 구분 여부를 나타내는 플래그 (ignoreCasetrue) 또는 대/소문자 구분 (ignoreCasefalse).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). 그런 다음 조건부 문에 플래그의 값을 평가할 수 있습니다.The value of the flag can then be evaluated in a conditional statement.

다음 예제에서는 간단한 콘솔 앱을를 사용 하 여 플래그로 부울 변수 사용법을 보여 줍니다.The following example uses a simple console app to illustrate the use of Boolean variables as flags. 에 지정된 된 파일에 출력을 사용 하도록 설정 하는 명령줄 매개 변수를 허용 하는 앱 (합니다 /f 전환), 출력 및 콘솔 모두 지정된 된 파일에 보낼 수 있는 (합니다 /b 전환).The app accepts command-line parameters that enable output to be redirected to a specified file (the /f switch), and that enable output to be sent both to a specified file and to the console (the /b switch). 라는 플래그를 정의 하는 앱 isRedirected 출력 파일을 전송할 수 있도록 이며 플래그 이름이 있는지 여부를 나타내기 위해 isBoth 출력을 콘솔에 보내야 한다고 나타냅니다.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

부울 및 산술 연산Booleans and arithmetic operations

부울 값을 수학적 계산을 트리거하는 조건의 있음을 표시 하기 위해 때때로 사용 됩니다.A Boolean value is sometimes used to indicate the presence of a condition that triggers a mathematical calculation. 예를 들어, 한 hasShippingCharge 변수를 전달 요금 청구서 금액에 추가할지 여부를 나타내는 플래그를 제공할 수 있습니다.For example, a hasShippingCharge variable might serve as a flag to indicate whether to add shipping charges to an invoice amount.

때문에 사용 하 여 작업을 false 값에 영향을 주지 않습니다 연산의 결과 대해 필요 없는 부울 수학 연산에서 사용 하는 정수 값으로 변환 하려면.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. 대신, 조건부 논리를 사용할 수 있습니다.Instead, you can use conditional logic.

다음 예제에서는 부분합을, 배송 비용 및 선택적 서비스 요금을 구성 하는 금액을 계산 합니다.The following example computes an amount that consists of a subtotal, a shipping charge, and an optional service charge. hasServiceCharge 변수 서비스 요금은 적용 되는지 여부를 결정 합니다.The hasServiceCharge variable determines whether the service charge is applied. 변환 하는 대신 hasServiceCharge 숫자 값을 서비스 요금은 양을 기준으로 곱한 예제를 사용 하 여 조건부 논리 적용 가능한 경우 서비스 요금 금액을 추가 합니다.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.

않음은 Booleans 및 interopBooleans and interop

기본 데이터 형식을 COM 마샬링 하는 것은 일반적으로 간단 하지만 Boolean 데이터 형식은 예외입니다.While marshaling base data types to COM is generally straightforward, the Boolean data type is an exception. 적용할 수 있습니다는 MarshalAsAttribute 특성을 마샬링하는 Boolean 다음 표현에는 형식:You can apply the MarshalAsAttribute attribute to marshal the Boolean type to any of the following representations:

열거형 형식Enumeration type 관리 되지 않는 형식Unmanaged format
UnmanagedType.Bool 4 바이트 정수 값을 0이 아닌 모든 값을 나타냅니다 true 0 나타냅니다 false합니다.A 4-byte integer value, where any nonzero value represents true and 0 represents false. 기본 형식은이 Boolean 및 구조의 필드를 Boolean 플랫폼에서 매개 변수 호출 합니다.This is the default format of a Boolean field in a structure and of a Boolean parameter in platform invoke calls.
UnmanagedType.U1 여기서 1은 1 바이트 정수 값을 true 0 나타냅니다 false합니다.A 1-byte integer value, where the 1 represents true and 0 represents false.
UnmanagedType.VariantBool 2 바이트 정수 값, 여기서-1 나타냅니다 true 0 나타냅니다 false합니다.A 2-byte integer value, where -1 represents true and 0 represents false. 기본 형식은 Boolean COM interop 호출에 매개 변수입니다.This is the default format of a Boolean parameter in COM interop calls.

필드

FalseString FalseString FalseString FalseString

부울 값 false를 문자열로 나타냅니다. Represents the Boolean value false as a string. 이 필드는 읽기 전용입니다. This field is read-only.

TrueString TrueString TrueString TrueString

부울 값 true를 문자열로 나타냅니다. Represents the Boolean value true as a string. 이 필드는 읽기 전용입니다. This field is read-only.

메서드

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

이 인스턴스와 지정된 Boolean 개체를 비교하고 서로의 관계를 나타내는 정수를 반환합니다. 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)

이 인스턴스와 지정된 개체를 비교하고 서로의 관계를 나타내는 정수를 반환합니다. 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)

이 인스턴스가 지정된 Boolean 개체와 같은지를 나타내는 값을 반환합니다. Returns a value indicating whether this instance is equal to a specified Boolean object.

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

이 인스턴스가 지정된 개체와 같은지를 나타내는 값을 반환합니다. Returns a value indicating whether this instance is equal to a specified object.

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

이 인스턴스의 해시 코드를 반환합니다. Returns the hash code for this instance.

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

Boolean 값 형식에 대한 형식 코드를 반환합니다. 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)

논리 값의 지정된 문자열 표현을 해당하는 Boolean 값으로 변환합니다. Converts the specified string representation of a logical value to its Boolean equivalent.

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

이 인스턴스의 값을 해당하는 문자열 표현("True" 또는 "False")으로 변환합니다. Converts the value of this instance to its equivalent string representation (either "True" or "False").

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

이 인스턴스의 값을 해당하는 문자열 표현("True" 또는 "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)

논리 값의 지정된 문자열 표현을 해당하는 Boolean으로 변환하려고 시도합니다. Tries to convert the specified string representation of a logical value to its Boolean equivalent. 반환 값은 변환이 성공했는지 아니면 실패했는지를 나타냅니다. A return value indicates whether the conversion succeeded or failed.

명시적 인터페이스 구현

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)

이 멤버에 대한 설명은 ToBoolean(IFormatProvider)를 참조하세요. For a description of this member, see ToBoolean(IFormatProvider).

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

이 멤버에 대한 설명은 ToByte(IFormatProvider)를 참조하세요. For a description of this member, see ToByte(IFormatProvider).

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

이 변환은 지원되지 않습니다. This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다. Attempting to use this method throws an InvalidCastException.

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

이 변환은 지원되지 않습니다. This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다. Attempting to use this method throws an InvalidCastException.

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

이 멤버에 대한 설명은 ToDecimal(IFormatProvider)를 참조하십시오. For a description of this member, see ToDecimal(IFormatProvider)..

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

이 멤버에 대한 설명은 ToDouble(IFormatProvider)를 참조하십시오. For a description of this member, see ToDouble(IFormatProvider)..

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

이 멤버에 대한 설명은 ToInt16(IFormatProvider)를 참조하세요. For a description of this member, see ToInt16(IFormatProvider).

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

이 멤버에 대한 설명은 ToInt32(IFormatProvider)를 참조하세요. For a description of this member, see ToInt32(IFormatProvider).

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

이 멤버에 대한 설명은 ToInt64(IFormatProvider)를 참조하세요. For a description of this member, see ToInt64(IFormatProvider).

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

이 멤버에 대한 설명은 ToSByte(IFormatProvider)를 참조하세요. For a description of this member, see ToSByte(IFormatProvider).

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

이 멤버에 대한 설명은 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)

이 멤버에 대한 설명은 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)

이 멤버에 대한 설명은 ToUInt16(IFormatProvider)를 참조하세요. For a description of this member, see ToUInt16(IFormatProvider).

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

이 멤버에 대한 설명은 ToUInt32(IFormatProvider)를 참조하세요. For a description of this member, see ToUInt32(IFormatProvider).

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

이 멤버에 대한 설명은 ToUInt64(IFormatProvider)를 참조하세요. For a description of this member, see ToUInt64(IFormatProvider).

적용 대상

스레드 보안

이 유형의 모든 멤버는 스레드로부터 안전 합니다. All members of this type are thread safe. 인스턴스 상태를 수정 하려면 표시 되는 멤버는 실제로 새 값을 사용 하 여 초기화 된 새 인스턴스를 반환 합니다. Members that appear to modify instance state actually return a new instance initialized with the new value. 으로 다른 형식을 사용 하 여이 형식의 인스턴스를 포함 하는 공유 변수를 읽고 쓰는로 보호 되어야 스레드로부터 안전을 보장 하려면 잠금. 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.