변환Conversions

변환이 다른 형식 간에 값을 변경 하는 과정입니다.Conversion is the process of changing a value from one type to another. 형식의 값 예를 들어 Integer 형식의 값으로 변환할 수 Double, 또는 형식의 값 Derived 형식의 값으로 변환할 수 Base가정 하면, BaseDerived 클래스 이자 Derived에서 상속 Base합니다.For example, a value of type Integer can be converted to a value of type Double, or a value of type Derived can be converted to a value of type Base, assuming that Base and Derived are both classes and Derived inherits from Base. 변환에는 (두 번째 예제)와 같이 변경 하려면 값 자체를 사용 해야 합니다. 또는 이전 예에서 같이 값 표시에 변화가 필요할 수 있습니다.Conversions may not require the value itself to change (as in the latter example), or they may require significant changes in the value representation (as in the former example).

변환을 확대 또는 축소 될 수 있습니다.Conversions may either be widening or narrowing. A 확대 변환 형식에서 해당 값 도메인은 적어도 대규모, 원래 형식의 값 도메인 보다 큰 하지 하는 경우 다른 형식으로 변환 됩니다.A widening conversion is a conversion from a type to another type whose value domain is at least as big, if not bigger, than the original type's value domain. 확대 변환 실패 하지 않습니다.Widening conversions should never fail. A 축소 변환 형식에서 원래 형식 보다 더 작은 값이 도메인 또는 충분히 관련 되지 않은 해당 추가 주의 해야 경우 해당 값 도메인은 다른 형식으로 변환 수행 하는 변환 ( 변환할 때 예에서 IntegerString).A narrowing conversion is a conversion from a type to another type whose value domain is either smaller than the original type's value domain or sufficiently unrelated that extra care must be taken when doing the conversion (for example, when converting from Integer to String). 축소 변환 정보가 손실 수반 될 수 있습니다는 실패할 수 있습니다.Narrowing conversions, which may entail loss of information, can fail.

Identity 변환 (즉, 변환 된 형식에서 자신에 게) 및 기본 값 변환 (즉, 변환 Nothing) 모든 형식에 대해 정의 됩니다.The identity conversion (i.e. a conversion from a type to itself) and default value conversion (i.e. a conversion from Nothing) are defined for all types.

암시적 변환과 명시적 변환Implicit and Explicit Conversions

변환 일 수 있습니다 암시적 하거나 명시적합니다.Conversions can be either implicit or explicit. 암시적 변환은 모든 특수 구문 없이 발생합니다.Implicit conversions occur without any special syntax. 다음은 암시적으로 변환의 예는 Integer 값을 Long 값:The following is an example of implicit conversion of an Integer value to a Long value:

Module Test
    Sub Main()
        Dim intValue As Integer = 123
        Dim longValue As Long = intValue

        Console.WriteLine(intValue & " = " & longValue)
    End Sub
End Module

반면, 명시적 변환 캐스트 연산자를 필요합니다. 캐스트 연산자 없이 값에는 명시적 변환을 수행 하려고 하면 컴파일 타임 오류가 발생 합니다. 다음 예제에서는 명시적 변환이 사용 하 여 변환 하는 Long 값을 Integer 값.The following example uses an explicit conversion to convert a Long value to an Integer value.

Module Test
    Sub Main()
        Dim longValue As Long = 134
        Dim intValue As Integer = CInt(longValue)

        Console.WriteLine(longValue & " = " & intValue)
    End Sub
End Module

암시적 변환 집합 컴파일 환경에 따라 달라 집니다 및 Option Strict 문입니다. 엄격한 의미 체계를 사용 하는 경우 확대 변환 으로만 암시적으로 발생할 수 있습니다. 관대 한 의미 체계를 사용 하는 경우 모든 확대 변환과 축소 변환 (즉, 모든 변환을) 암시적으로 발생할 수 있습니다.If permissive semantics are being used, all widening and narrowing conversions (in other words, all conversions) may occur implicitly.

부울 변환Boolean Conversions

하지만 Boolean 형식이 아닌 숫자를 축소 변환에 숫자 유형에 서 열거 형식 처럼 않은 합니다.Although Boolean is not a numeric type, it does have narrowing conversions to and from the numeric types as if it were an enumerated type. 리터럴 True 리터럴 변환 255 에 대 한 Byte, 65535 에 대 한 UShort4294967295 에 대 한 UInteger18446744073709551615 에 대 한 ULong, 식 및 -1 에 대 한 SByte, ShortInteger, LongDecimalSingle, 및 Double합니다.The literal True converts to the literal 255 for Byte, 65535 for UShort, 4294967295 for UInteger, 18446744073709551615 for ULong, and to the expression -1 for SByte, Short, Integer, Long, Decimal, Single, and Double. 리터럴 False 리터럴 변환 0합니다.The literal False converts to the literal 0. 리터럴 숫자 값을 0으로 변환 False합니다.A zero numeric value converts to the literal False. 다른 모든 숫자 값을 리터럴로 변환 True합니다.All other numeric values convert to the literal True.

부울에서 문자열을 변환에 축소 변환이 있기 System.Boolean.TrueString 또는 System.Boolean.FalseString합니다.There is a narrowing conversion from Boolean to String, converting to either System.Boolean.TrueString or System.Boolean.FalseString. 축소 변환 이기도 StringBoolean: 문자열 같음 되었으면 TrueString 또는 FalseString (현재 문화권을 대) 적절 한 값을 사용 하 여, 그렇지 않으면 문자열을 구문 분석 하려고를 숫자 형식 (16 진수 또는 8 진수에서 가능한 float로이 고 그렇지) 및 위의 규칙; 사용 그렇지 않으면 throw System.InvalidCastException합니다.There is also a narrowing conversion from String to Boolean: if the string was equal to TrueString or FalseString (in the current culture, case-insensitively) then it uses the appropriate value; otherwise it attempts to parse the string as a numeric type (in hex or octal if possible, otherwise as a float) and uses the above rules; otherwise it throws System.InvalidCastException.

숫자 변환Numeric Conversions

형식 사이 숫자 변환이 Byte, SByte, UShort, Short, UIntegerInteger, ULongLong, DecimalSingleDouble, 와 모든 열거형된 형식입니다.Numeric conversions exist between the types Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single and Double, and all enumerated types. 으로 변환 될 때 열거 형식은 해당 기본 형식 처럼 처리 됩니다.When being converted, enumerated types are treated as if they were their underlying types. 열거 형식으로 변환 하는 경우에 열거 형식에 정의 된 값 집합에 맞게 원본 값 않아도 됩니다.When converting to an enumerated type, the source value is not required to conform to the set of values defined in the enumerated type. 예를 들어:For example:

Enum Values
    One
    Two
    Three
End Enum

Module Test
    Sub Main()
        Dim x As Integer = 5

        ' OK, even though there is no enumerated value for 5.
        Dim y As Values = CType(x, Values)
    End Sub
End Module

숫자 변환 런타임 시 다음과 같이 처리 됩니다.Numeric conversions are processed at run-time as follows:

  • 더 광범위 한 숫자 형식으로 숫자 형식에서 변환의 값은 단순히 더 광범위 한 형식으로 변환 됩니다.For a conversion from a numeric type to a wider numeric type, the value is simply converted to the wider type. 변환할 UInteger, Integer, ULong, Long, 또는 DecimalSingle 또는 Double 반올림 됩니다 가장 가까운 Single 또는 Double 값입니다.Conversions from UInteger, Integer, ULong, Long, or Decimal to Single or Double are rounded to the nearest Single or Double value. 이 변환은 정밀도의 손실 될 수 있습니다, 있지만 크기는 손실을 발생 하지 않습니다.While this conversion may cause a loss of precision, it will never cause a loss of magnitude.

  • 다른 정수 계열 형식으로 또는 정수 계열 형식에서 변환 Single, Double, 또는 Decimal 정수 계열 형식으로 결과 인지에 따라 다릅니다 정수 오버플로 검사에서:For a conversion from an integral type to another integral type, or from Single, Double, or Decimal to an integral type, the result depends on whether integer overflow checking is on:

    정수 오버플로 검사 합니다.If integer overflow is being checked:

    • 원본 정수 계열 형식 이면 소스 인수 대상 형식의 범위 내에 있으면 변환이 성공 합니다.If the source is an integral type, the conversion succeeds if the source argument is within the range of the destination type. 변환 throw를 System.OverflowException 예외 소스 인수 대상 형식의 범위를 벗어난 경우.The conversion throws a System.OverflowException exception if the source argument is outside the range of the destination type.

    • 소스가 Single, Double, 또는 Decimal소스 값은 반올림 되거나 내림 됩니다 가장 가까운 정수 값을 정수 값이 변환의 결과가 됩니다.If the source is Single, Double, or Decimal, the source value is rounded up or down to the nearest integral value, and this integral value becomes the result of the conversion. 이면 소스 값을 동일 하 게 두 정수 값에 가까운 값 수는 짝수 최하위 숫자 위치에 있는 값으로 반올림 됩니다.If the source value is equally close to two integral values, the value is rounded to the value that has an even number in the least significant digit position. 결과 정수 값을 대상 형식의 범위를 벗어난 경우는 System.OverflowException 예외가 throw 됩니다.If the resulting integral value is outside the range of the destination type, a System.OverflowException exception is thrown.

    정수 오버플로 선택 하지 않으면:If integer overflow is not being checked:

    • 원본 정수 계열 형식 이면 변환이 항상 성공 하 고 원본 값의 가장 중요 한 비트가 무시 합니다.If the source is an integral type, the conversion always succeeds and simply consists of discarding the most significant bits of the source value.

    • 소스가 Single, Double, 또는 Decimal, 변환을 항상 성공 하 고 가장 가까운 정수 값으로 원본 값을 반올림 만으로 구성 됩니다.If the source is Single, Double, or Decimal, the conversion always succeeds and simply consists of rounding the source value towards the nearest integral value. 이면 소스 값을 동일 하 게 두 정수 값에 가까운 값 수는 짝수 최하위 숫자 위치에 있는 값으로 항상 반올림 됩니다.If the source value is equally close to two integral values, the value is always rounded to the value that has an even number in the least significant digit position.

  • 변환에 대 한 DoubleSingleDouble 값은 반올림 가장 가까운 Single 값입니다.For a conversion from Double to Single, the Double value is rounded to the nearest Single value. 경우는 Double 값이 너무 작아서로 나타낼 수는 Single, 결과 양의 0 또는 음의 0입니다.If the Double value is too small to represent as a Single, the result becomes positive zero or negative zero. 경우는 Double 값이 너무 커서로 나타낼 수는 Single, 결과 양의 무한대 또는 음의 무한대입니다.If the Double value is too large to represent as a Single, the result becomes positive infinity or negative infinity. 경우는 Double 가치가 NaN, 결과도 NaN합니다.If the Double value is NaN, the result is also NaN.

  • 변환에 대 한 Single 또는 DoubleDecimal, 소스 값으로 변환 됩니다 Decimal 표현이 필요한 경우 소수 자릿수가 28 가장 가까운 수로 반올림 합니다.For a conversion from Single or Double to Decimal, the source value is converted to Decimal representation and rounded to the nearest number after the 28th decimal place if required. 원본 값이 너무 작아로 나타낼 수 없는 경우는 Decimal, 결과 0이 됩니다.If the source value is too small to represent as a Decimal, the result becomes zero. 원본 값이 NaN, 무한대 또는 너무 커서로 나타낼 수는 Decimal, System.OverflowException 예외가 throw 됩니다.If the source value is NaN, infinity, or too large to represent as a Decimal, a System.OverflowException exception is thrown.

  • 변환에 대 한 DoubleSingleDouble 값은 반올림 가장 가까운 Single 값입니다.For a conversion from Double to Single, the Double value is rounded to the nearest Single value. 경우는 Double 값이 너무 작아서로 나타낼 수는 Single, 결과 양의 0 또는 음의 0입니다.If the Double value is too small to represent as a Single, the result becomes positive zero or negative zero. 경우는 Double 값이 너무 커서로 나타낼 수는 Single, 결과 양의 무한대 또는 음의 무한대입니다.If the Double value is too large to represent as a Single, the result becomes positive infinity or negative infinity. 경우는 Double 가치가 NaN, 결과도 NaN합니다.If the Double value is NaN, the result is also NaN.

참조 변환Reference Conversions

참조 형식의 기본 형식, 그 반대로 변환 될 수 있습니다.Reference types may be converted to a base type, and vice versa. 더 많이 파생 된 형식에 기본 형식에서 변환 변환 되는 값은 null 값, 파생된 형식 자체 또는 더 많이 파생 된 형식인 경우에 런타임에 성공 합니다.Conversions from a base type to a more derived type only succeed at run time if the value being converted is a null value, the derived type itself, or a more derived type.

클래스 및 인터페이스 형식에서 임의의 인터페이스 형식 캐스팅할 수 있습니다.Class and interface types can be cast to and from any interface type. 관련 된 실제 형식 상속 또는 구현 관계를 사용 하는 경우 런타임 시 형식 및 인터페이스 형식 간의 변환을 성공 합니다.Conversions between a type and an interface type only succeed at run time if the actual types involved have an inheritance or implementation relationship. 인터페이스 형식에서 파생 되는 형식의 인스턴스를 항상 포함 되므로 Object, 인터페이스 형식으로 캐스팅할 수 항상 Object합니다.Because an interface type will always contain an instance of a type that derives from Object, an interface type can also always be cast to and from Object.

참고 합니다.Note. 변환할 오류가 아닌 한 NotInheritable 클래스 COM 클래스를 나타내는 클래스 인터페이스 구현 될 때까지 알려지지 않은 있을 수 있으므로 구현 하지 않는 인터페이스를 실행 시간입니다.It is not an error to convert a NotInheritable classes to and from interfaces that it does not implement because classes that represent COM classes may have interface implementations that are not known until run time.

런타임에 참조 변환에 실패 하는 경우는 System.InvalidCastException 예외가 throw 됩니다.If a reference conversion fails at run time, a System.InvalidCastException exception is thrown.

참조 분산 변환Reference Variance Conversions

제네릭 인터페이스 또는 대리자는 호환 변형의 형식 간의 변환을 허용 하는 variant 형식 매개 변수가 있을 수 있습니다.Generic interfaces or delegates may have variant type parameters that allow conversions between compatible variants of the type. 따라서 런타임에 클래스 유형 또는 인터페이스 형식에서 variant 인터페이스 형식에서 상속 하거나 구현와 호환 되는 인터페이스 형식으로 변환 성공 합니다.Therefore, at runtime a conversion from a class type or an interface type to an interface type that is variant compatible with an interface type it inherits from or implements will succeed. 마찬가지로 대리자 형식으로 캐스팅 될 수 하 고 호환 되는 변형에서 대리자 형식입니다.Similarly, delegate types can be cast to and from variant compatible delegate types. 예를 들어 대리자 형식For example, the delegate type

Delegate Function F(Of In A, Out R)(a As A) As R

으로 변환 하면 F(Of Object, Integer)F(Of String, Integer)입니다.would allow a conversion from F(Of Object, Integer) to F(Of String, Integer). 즉, 대리자 F 사용 하는 Object 대리자로 안전 하 게 사용할 수 있습니다 F 사용 하는 String합니다.That is, a delegate F which takes Object may be safely used as a delegate F which takes String. 대리자 호출 되 면 대상 메서드는 개체로을 예상 및 문자열은 개체입니다.When the delegate is invoked, the target method will be expecting an object, and a string is an object.

제네릭 대리자 또는 인터페이스 형식 S(Of S1,...,Sn) 이라고 variant 호환 제네릭 인터페이스 또는 대리자 형식과 T(Of T1,...,Tn) 경우:A generic delegate or interface type S(Of S1,...,Sn) is said to be variant compatible with a generic interface or delegate type T(Of T1,...,Tn) if:

  • ST 동일한 제네릭 형식에서 생성 된 U(Of U1,...,Un)합니다.S and T are both constructed from the same generic type U(Of U1,...,Un).

  • 각 형식 매개 변수에 대해 Ux:For each type parameter Ux:

    • 그런 다음 분산 하지 않고 형식 매개 변수 선언 되었으면 SxTx 동일한 형식 이어야 합니다.If the type parameter was declared without variance then Sx and Tx must be the same type.

    • 형식 매개 변수 선언 되었으면 In 는 확대 id, 기본, 참조, 배열 또는 형식 이어야 합니다에서 매개 변수 변환 SxTx입니다.If the type parameter was declared In then there must be a widening identity, default, reference, array, or type parameter conversion from Sx to Tx.

    • 형식 매개 변수 선언 되었으면 Out 는 확대 id, 기본, 참조, 배열 또는 형식 이어야 합니다에서 매개 변수 변환 TxSx입니다.If the type parameter was declared Out then there must be a widening identity, default, reference, array, or type parameter conversion from Tx to Sx.

클래스는 둘 이상의 변형 호환 되는 인터페이스를 구현 하는 경우 클래스에서 variant 형식 매개 변수가 있는 제네릭 인터페이스를 변환 하는 경우 변환이 아닌 변형 변환이 없는 경우 모호 합니다.When converting from a class to a generic interface with variant type parameters, if the class implements more than one variant compatible interface the conversion is ambiguous if there is not a non-variant conversion. 예를 들어:For example:

Class Base
End Class

Class Derived1
    Inherits Base
End Class

Class Derived2
    Inherits Base
End Class

Class OneAndTwo
    Implements IEnumerable(Of Derived1)
    Implements IEnumerable(Of Derived2)
End Class

Class BaseAndOneAndTwo
    Implements IEnumerable(Of Base)
    Implements IEnumerable(Of Derived1)
    Implements IEnumerable(Of Derived2)
End Class

Module Test
    Sub Main()
        ' Error: conversion is ambiguous
        Dim x As IEnumerable(Of Base) = New OneAndTwo()

        ' OK, will pick up the direct implementation of IEnumerable(Of Base)
        Dim y as IEnumerable(Of Base) = New BaseAndOneAndTwo()
    End Sub
End Module

익명 대리자 변환Anonymous Delegate Conversions

식 람다 메서드로 분류는 컨텍스트에서 값으로 다시 분류 하는 경우 대상 유형이 없는 경우 (예를 들어 Dim x = Function(a As Integer, b As Integer) a + b), 또는 결과 식의 형식이 익명 대리자 형식인 대상 유형을 대리자 형식이 아닌 경우 lambda 메서드 서명의에 해당 합니다.When an expression classified as a lambda method is reclassified as a value in a context where there is no target type (for example, Dim x = Function(a As Integer, b As Integer) a + b), or where the target type is not a delegate type, the type of the resulting expression is an anonymous delegate type equivalent to the signature of the lambda method. 이 익명 대리자 형식은 호환 되는 대리자 형식으로 변환 합니다: 호환 되는 대리자 형식이 익명 대리자 형식을 사용 하 여 대리자 생성 식을 사용 하 여 만들 수 있는 모든 대리자 형식을 Invoke 메서드에 매개 변수로 합니다.This anonymous delegate type has a conversion to any compatible delegate type: a compatible delegate type is any delegate type that can be created using a delegate creation expression with the anonymous delegate type's Invoke method as a parameter. 예를 들어:For example:

' Anonymous delegate type similar to Func(Of Object, Object, Object)
Dim x = Function(x, y) x + y

' OK because delegate type is compatible
Dim y As Func(Of Integer, Integer, Integer) = x

유형에 System.DelegateSystem.MulticastDelegate 하지 자체 라고 대리자 형식 (경우에 모든 대리자 형식에서 상속).Note that the types System.Delegate and System.MulticastDelegate are not themselves considered delegate types (even though all delegate types inherit from them). 또한 참고 변환 하는 익명 대리자 형식의 호환 되는 대리자 형식에는 아니며 참조 변환Also, note that the conversion from anonymous delegate type to a compatible delegate type is not a reference conversion.

배열 변환Array Conversions

사실 때문에 참조 형식 배열에 정의 된 변환을 외에도 몇 가지 특수 변환 배열에 대 한 존재 합니다.Besides the conversions that are defined on arrays by virtue of the fact that they are reference types, several special conversions exist for arrays.

두 형식에 대 한 A 하 고 B경우 참조 형식 또는 값 형식으로 알 수 없는 형식 매개 변수를 둘 다를 경우 A 참조, 배열, 또는 형식에 매개 변수 변환 B, 배열에서에 대 한 변환이 존재 형식 A 형식의 배열에 B 고 동일한 차수로 합니다.For any two types A and B, if they are both reference types or type parameters not known to be value types, and if A has a reference, array, or type parameter conversion to B, a conversion exists from an array of type A to an array of type B with the same rank. 이 관계 라고 배열 공변성 (covariance) 합니다.This relationship is known as array covariance. 배열 공변성 (covariance) 특히 의미를 가지 며 요소 형식이 배열 요소의 B 가지 며 요소 형식이 배열 요소는 실제로 있을 A단, 둘 다 AB 참조 형식 및 해당 B 변환할 배열 또는 참조 변환이 A합니다.Array covariance in particular means that an element of an array whose element type is B may actually be an element of an array whose element type is A, provided that both A and B are reference types and that B has a reference conversion or array conversion to A. 다음 예제에서는 두 번째 호출에서에서 F 발생을 System.ArrayTypeMismatchException 의 실제 요소 형식 때문에 예외가 b 됩니다 String아니라 Object:In the following example, the second invocation of F causes a System.ArrayTypeMismatchException exception to be thrown because the actual element type of b is String, not Object:

Module Test
    Sub F(ByRef x As Object)
    End Sub

    Sub Main()
        Dim a(10) As Object
        Dim b() As Object = New String(10) {}
        F(a(0)) ' OK.
        F(b(1)) ' Not allowed: System.ArrayTypeMismatchException.
   End Sub
End Module

배열 공 분산으로 인해 참조 형식 배열의 요소에 대 한 할당 배열 요소에 할당 되는 값이 허용 된 형식의 실제로 인지 확인 하는 런타임 검사를 포함 합니다.Because of array covariance, assignments to elements of reference type arrays include a run-time check that ensures that the value being assigned to the array element is actually of a permitted type.

Module Test
    Sub Fill(array() As Object, index As Integer, count As Integer, _
            value As Object)
        Dim i As Integer

        For i = index To (index + count) - 1
            array(i) = value
        Next i
    End Sub

    Sub Main()
        Dim strings(100) As String

        Fill(strings, 0, 101, "Undefined")
        Fill(strings, 0, 10, Nothing)
        Fill(strings, 91, 10, 0)
    End Sub
End Module

이 예에 대 한 할당 array(i) 메서드에서 Fill 변수로 참조 하는 개체 되도록 하는 런타임 검사를 명시적으로 포함 valueNothing 또는 호환 되는 형식의 인스턴스를 배열의 실제 요소 형식을 array합니다.In this example, the assignment to array(i) in method Fill implicitly includes a run-time check that ensures that the object referenced by the variable value is either Nothing or an instance of a type that is compatible with the actual element type of array array. 메서드에서 Main, 메서드의 처음 두 호출 Fill 성공 하지만 세 번째 호출 하면을 System.ArrayTypeMismatchException 예외를 throw 하는 첫 번째 할당을 실행할 때 array(i)합니다.In method Main, the first two invocations of method Fill succeed, but the third invocation causes a System.ArrayTypeMismatchException exception to be thrown upon executing the first assignment to array(i). 예외가 발생 하기 때문에 Integer 에 저장할 수 없습니다는 String 배열입니다.The exception occurs because an Integer cannot be stored in a String array.

형식 매개 변수 형식이 판명 런타임에 값 형식일 경우 배열 요소 형식 중 하나는 System.InvalidCastException 예외가 throw 됩니다.If one of the array element types is a type parameter whose type turns out to be a value type at runtime, a System.InvalidCastException exception will be thrown. 예를 들어:For example:

Module Test
    Sub F(Of T As U, U)(x() As T)
        Dim y() As U = x
    End Sub

    Sub Main()
        ' F will throw an exception because Integer() cannot be
        ' converted to Object()
        F(New Integer() { 1, 2, 3 })
    End Sub
End Module

도 서로 변환 열거 형식의 배열 및 배열은 동일한 순위로 제공 열거 형식의 배열 형식 또는 다른 열거형된 형식과 동일한 기본 형식의 배열을 기본의입니다.Conversions also exist between an array of an enumerated type and an array of the enumerated type's underlying type or an array of another enumerated type with the same underlying type, provided the arrays have the same rank.

Enum Color As Byte
    Red
    Green
    Blue
End Enum

Module Test
    Sub Main()
        Dim a(10) As Color
        Dim b() As Integer
        Dim c() As Byte

        b = a    ' Error: Integer is not the underlying type of Color
        c = a    ' OK
        a = c    ' OK
    End Sub
End Module

이 예제에서는 배열 Color 배열을으로 변환 됩니다 Byte, Color의 내부 형식입니다.In this example, an array of Color is converted to and from an array of Byte, Color's underlying type. 그러나 배열로 변환 Integer, 됩니다 오류가 있으므로 Integer 의 기본 형식이 아닌 Color합니다.The conversion to an array of Integer, however, will be an error because Integer is not the underlying type of Color.

형식의 차수가 1 배열 A() 역시 컬렉션 인터페이스 형식으로 변환 하는 배열 변환을 IList(Of B), IReadOnlyList(Of B), ICollection(Of B), IReadOnlyCollection(Of B)IEnumerable(Of B) 에서 찾을 System.Collections.Generic. 단, 다음 중 하나에:A rank-1 array of type A() also has an array conversion to the collection interface types IList(Of B), IReadOnlyList(Of B), ICollection(Of B), IReadOnlyCollection(Of B) and IEnumerable(Of B) found in System.Collections.Generic, so long as one of the following is true:

  • AB 는 모두 참조 형식 또는 값 형식; 알 수 없는 형식 매개 변수 및 A 확대 참조, 배열 또는 형식 매개 변수 변환에 B; 또는A and B are both reference types or type parameters not known to be value types; and A has a widening reference, array or type parameter conversion to B; or
  • AB 두 열거 유형의 동일한 기본 형식을; 또는A and B are both enumerated types of the same underlying type; or
  • 중 하나 AB 열거 형식이 고 다른 하나는 기본 형식입니다.one of A and B is an enumerated type, and the other is its underlying type.

순위를 사용 하 여 입력의 모든 배열 역시 제네릭이 아닌 컬렉션 인터페이스 형식으로 변환 하는 배열 변환을 IList, ICollection 하 고 IEnumerable 에서 찾을 System.Collections합니다.Any array of type A with any rank also has an array conversion to the non-generic collection interface types IList, ICollection and IEnumerable found in System.Collections.

사용 하 여 결과 인터페이스를 통해 반복 하는 것이 불가능 For Each, 또는 호출을 통해는 GetEnumerator 메서드를 직접.It is possible to iterate over the resulting interfaces using For Each, or through invoking the GetEnumerator methods directly. 배열 순위 1의 경우 제네릭 컬렉션과 제네릭이 아닌 형식의 변환 IList 또는 ICollection를 인덱스에서 요소를 가져올 수 이기도 합니다.In the case of rank-1 arrays converted generic or non-generic forms of IList or ICollection, it is also possible to get elements by index. 제네릭 컬렉션과 제네릭이 아닌 형식으로 변환 하는 순위 1 배열 경우 IList인덱스로 요소를 설정할 수 이기도, 동일한 런타임을 따라 배열 공변성 (covariance) 위에 설명 된 대로 확인 합니다.In the case of rank-1 arrays converted to generic or non-generic forms of IList, it is also possible to set elements by index, subject to the same runtime array covariance checks as described above. VB 언어 사양;에 정의 되지 않은 다른 모든 인터페이스 메서드의 동작 것은 기본 런타임입니다.The behavior of all other interface methods is undefined by the VB language specification; it is up to the underlying runtime.

값 형식 변환Value Type Conversions

값 형식 값을 해당 기본 참조 형식 또는 라는 프로세스를 통해 구현 하는 인터페이스 형식 중 하나로 변환할 수 boxing합니다.A value type value can be converted to one of its base reference types or an interface type that it implements through a process called boxing. 값 형식, boxed 값은.NET Framework 힙으로 거주 위치에서 복사 됩니다.When a value type value is boxed, the value is copied from the location where it lives onto the .NET Framework heap. 힙에서이 위치에 대 한 참조가 반환 됩니다 및 참조 형식 변수를 저장할 수 있습니다.A reference to this location on the heap is then returned and can be stored in a reference type variable. 이 참조는 라고도 하는 boxed 값 형식의 인스턴스입니다.This reference is also referred to as a boxed instance of the value type. Boxed 인스턴스 값 형식이 아닌 참조 형식으로 동일한 의미 체계를 가집니다.The boxed instance has the same semantics as a reference type instead of a value type.

Boxed 값 형식은 라는 프로세스를 통해 해당 원래 값 형식으로 다시 변환할 수 있습니다 unboxing합니다.Boxed value types can be converted back to their original value type through a process called unboxing. Boxed 값 형식이 boxed 없는 경우 값은 힙의 변수 위치에 복사 됩니다.When a boxed value type is unboxed, the value is copied from the heap into a variable location. 해당 지점에서 값 형식 이었던 것 처럼 작동 합니다.From that point on, it behaves as if it was a value type. 값 형식, unboxing 하는 경우 null 값 또는 값 형식의 인스턴스로 값 이어야 합니다.When unboxing a value type, the value must be a null value or an instance of the value type. 그렇지 않은 경우는 System.InvalidCastException 예외가 throw 됩니다.Otherwise a System.InvalidCastException exception is thrown. 값 열거 형식 인스턴스의 경우 해당 값도 수 boxed 열거형된 형식에 기본 형식 또는 같은 다른 열거형된 형식의 기본 형식입니다.If the value is an instance of an enumerated type, that value can also be unboxed to the enumerated type's underlying type or another enumerated type that has the same underlying type. Null 값을 리터럴 것 처럼 처리 됩니다 Nothing합니다.A null value is treated as if it were the literal Nothing.

Nullable 지원 하기 위해 값 형식, 값 형식 System.Nullable(Of T) 특별히 수행할 때 boxing 및 unboxing 처리 됩니다.To support nullable value types well, the value type System.Nullable(Of T) is treated specially when doing boxing and unboxing. 형식의 값을 boxing Nullable(Of T) 형식의 boxed 값을 반환 T 경우 값의 HasValue 속성이 TrueNothing 하는 경우 값의 HasValue 속성이 False합니다.Boxing a value of type Nullable(Of T) results in a boxed value of type T if the value's HasValue property is True or a value of Nothing if the value's HasValue property is False. 형식의 값을 unboxing TNullable(Of T) 인스턴스의 결과 Nullable(Of T)Value boxed 값 및 해당 속성은 HasValue 속성이 True합니다.Unboxing a value of type T to Nullable(Of T) results in an instance of Nullable(Of T) whose Value property is the boxed value and whose HasValue property is True. Nothing 에 unboxed 수 Nullable(Of T) 에 대 한 T 결과에 값을 갖는 HasValue 속성이 False.The value Nothing can be unboxed to Nullable(Of T) for any T and results in a value whose HasValue property is False. Boxed 값 형식 참조 처럼 동작 하기 때문에 동일한 값에 대 한 여러 참조를 만들 수는 형식입니다.Because boxed value types behave like reference types, it is possible to create multiple references to the same value. 기본 형식 및 열거형된 형식에 대 한이 아니므로 관련 해당 형식의 인스턴스가 변경할 수 없는합니다.For the primitive types and enumerated types, this is irrelevant because instances of those types are immutable. 즉, 이므로 동일한 값에 대 한 참조를 여러 가지 팩트를 확인할 수 있습니다 이러한 형식의 boxed 인스턴스를 수정할 수 아닙니다.That is, it is not possible to modify a boxed instance of those types, so it is not possible to observe the fact that there are multiple references to the same value.

구조, 반면에 또는 수 있습니다 변경할 수 있는 해당 인스턴스 변수에 액세스할 수 있는 경우 해당 메서드 또는 속성의 인스턴스 변수를 수정 하는 경우.Structures, on the other hand, may be mutable if its instance variables are accessible or if its methods or properties modify its instance variables. Boxed 구조체에 대 한 참조가 구조를 수정 하려면 사용 하는 경우 변경 boxed 구조체에 대 한 모든 참조에 표시 됩니다.If one reference to a boxed structure is used to modify the structure, then all references to the boxed structure will see the change. 이 결과 예상 되지 않을 수, 때문에 경우 값을 입력으로 Object 한곳에서 형식을 자동으로 복사 하는 해당 참조는 단순히 대신 힙에 복제할 다른 boxed 값으로 복사 됩니다.Because this result may be unexpected, when a value typed as Object is copied from one location to another boxed value types will automatically be cloned on the heap instead of merely having their references copied. 예를 들어:For example:

Class Class1
    Public Value As Integer = 0
End Class

Structure Struct1
    Public Value As Integer
End Structure

Module Test
    Sub Main()
        Dim val1 As Object = New Struct1()
        Dim val2 As Object = val1

        val2.Value = 123

        Dim ref1 As Object = New Class1()
        Dim ref2 As Object = ref1

        ref2.Value = 123

        Console.WriteLine("Values: " & val1.Value & ", " & val2.Value)
        Console.WriteLine("Refs: " & ref1.Value & ", " & ref2.Value)
    End Sub
End Module

프로그램의 출력이 됩니다.The output of the program is:

Values: 0, 123
Refs: 123, 123

지역 변수의 필드에 할당 val2 지역 변수의 필드에 영향을 주지 않습니다 val1 때문에 경우 boxed Struct1 에 할당 된 val2, 값의 복사본을 만들었습니다.The assignment to the field of the local variable val2 does not impact the field of the local variable val1 because when the boxed Struct1 was assigned to val2, a copy of the value was made. 반대로, 할당 ref2.Value = 123 개체에 영향을 줍니다는 둘 다 ref1ref2 참조 합니다.In contrast, the assignment ref2.Value = 123 affects the object that both ref1 and ref2 references.

참고 합니다.Note. 로 형식화 된 boxed 구조체에 대 한 구조 복사를 수행 하지 System.ValueType 런타임에 바인딩 해제의 수 없기 때문에 System.ValueType입니다.Structure copying is not done for boxed structures typed as System.ValueType because it is not possible to late bind off of System.ValueType.

boxed 값 할당 시 형식을 복사할 수 있는 규칙에 대 한 예외가 있습니다.There is one exception to the rule that boxed value types will be copied on assignment. Boxed 값 형식 참조를 다른 형식 내에 저장 된 경우에 내부 참조를 복사 되지 않습니다.If a boxed value type reference is stored within another type, the inner reference will not be copied. 예를 들어:For example:

Structure Struct1
    Public Value As Object
End Structure

Module Test
    Sub Main()
        Dim val1 As Struct1
        Dim val2 As Struct1

        val1.Value = New Struct1()
        val1.Value.Value = 10

        val2 = val1
        val2.Value.Value = 123
        Console.WriteLine("Values: " & val1.Value.Value & ", " & _
            val2.Value.Value)
    End Sub
End Module

프로그램의 출력이 됩니다.The output of the program is:

Values: 123, 123

즉, 내부 boxed 값을 값으로 복사 되 면 복사 되지 않습니다.This is because the inner boxed value is not copied when the value is copied. 따라서 둘 다 val1.Valueval2.Value 동일한 boxed 값 형식에 대 한 참조입니다.Thus, both val1.Value and val2.Value have a reference to the same boxed value type.

참고 합니다.Note. 내부 boxed 값 형식 복사 되지 않습니다 사실.NET 제한인 형식 시스템-모든 내부 boxed 값 형식 복사 된 때마다 형식의 값을 확인할 수 Object 복사 된 많은 비용이 들거나 실행 됩니다.The fact that inner boxed value types are not copied is a limitation of the .NET type system -- to ensure that all inner boxed value types were copied whenever a value of type Object was copied would be prohibitively expensive.

앞에서 설명한, boxed 값으로 형식만 수는 원래 형식으로 boxed 합니다.As previously described, boxed value types can only be unboxed to their original type. 그러나 Boxed 형식 처리할지로 형식화 된 경우에 특별히 Object합니다.Boxed primitive types, however, are treated specially when typed as Object. 변환할 수 있는 다른 기본 유형으로 변환할 수 있습니다.They can be converted to any other primitive type that they have a conversion to. 예를 들어:For example:

Module Test
    Sub Main()
        Dim o As Object = 5
        Dim b As Byte = CByte(o)  ' Legal
        Console.WriteLine(b) ' Prints 5
    End Sub
End Module

일반적으로 boxed Integer5 으로 unboxed 없습니다 수는 Byte 변수입니다.Normally, the boxed Integer value 5 could not be unboxed into a Byte variable. 그러나 때문 IntegerByte 기본 형식이 며, 변환을 수행할 변환이 허용 됩니다.However, because Integer and Byte are primitive types and have a conversion, the conversion is allowed.

값 형식 인터페이스 변환할 다른 제네릭 인수 인터페이스로 제한 보다는 두는 것이 반드시 합니다.It is important to note that converting a value type to an interface is different than a generic argument constrained to an interface. 제한 된 형식 매개 변수에 인터페이스 멤버에 액세스할 때 (에서 메서드를 호출 하거나 Object), boxing 값 형식 인터페이스로 변환 되 고 인터페이스 멤버를 액세스할 때와 발생 하지 않습니다.When accessing interface members on a constrained type parameter (or calling methods on Object), boxing does not occur as it does when a value type is converted to an interface and an interface member is accessed. 예를 들어 인터페이스로 ICounter 메서드를 포함 Increment 값을 수정에 사용할 수 있는 합니다.For example, suppose an interface ICounter contains a method Increment which can be used to modify a value. 하는 경우 ICounter 구현의 제약 조건으로 사용 되는 Increment 메서드는 변수에 대 한 참조를 사용 하 여는 Increment boxed 복사본이 아니라에서 호출 된:If ICounter is used as a constraint, the implementation of the Increment method is called with a reference to the variable that Increment was called on, not a boxed copy:

Interface ICounter
    Sub Increment()
    ReadOnly Property Value() As Integer
End Interface

Structure Counter
    Implements ICounter

    Dim _value As Integer

    Property Value() As Integer Implements ICounter.Value
        Get
            Return _value
        End Get
    End Property

    Sub Increment() Implements ICounter.Increment
       value += 1
    End Sub
End Structure

Module Test
      Sub Test(Of T As ICounter)(x As T)
         Console.WriteLine(x.value)
         x.Increment()                     ' Modify x
         Console.WriteLine(x.value)
         CType(x, ICounter).Increment()    ' Modify boxed copy of x
         Console.WriteLine(x.value)
      End Sub

      Sub Main()
         Dim x As Counter
         Test(x)
      End Sub
End Module

첫 번째 호출은 Increment 변수의 값을 수정 x합니다.The first call to Increment modifies the value in the variable x. 두 번째 호출은 동일 하지 않습니다 Increment의 boxed 사본이의 값을 수정 하는 x합니다.This is not equivalent to the second call to Increment, which modifies the value in a boxed copy of x. 따라서 프로그램의 출력이 됩니다.Thus, the output of the program is:

0
1
1

Nullable 값 형식 변환Nullable Value Type Conversions

값 형식 T 형식의 nullable 버전에서 변환할 수 T?입니다.A value type T can convert to and from the nullable version of the type, T?. 변환 T?T throw를 System.InvalidOperationException 예외 변환 되는 값 이면 Nothing합니다.The conversion from T? to T throws a System.InvalidOperationException exception if the value being converted is Nothing. 또한 T? 형식으로 변환 했습니다 S 하는 경우 T 내장 함수는 변환에 S입니다.Also, T? has a conversion to a type S if T has an intrinsic conversion to S. 경우에 S 가 값 형식 간에 다음과 같은 내장 변환이 존재 T?S?:And if S is a value type, then the following intrinsic conversions exist between T? and S?:

  • 동일한 분류 (축소 또는 확대)으로 변환할 T?S?입니다.A conversion of the same classification (narrowing or widening) from T? to S?.

  • 동일한 분류 (축소 또는 확대)으로 변환할 TS?입니다.A conversion of the same classification (narrowing or widening) from T to S?.

  • 축소 변환 S?T입니다.A narrowing conversion from S? to T.

내장 함수는 확대 변환이 존재 하는 예를 들어 Integer?Long? 에서 내장 함수는 확대 변환이 있으므로 Integer 하려면 Long:For example, an intrinsic widening conversion exists from Integer? to Long? because an intrinsic widening conversion exists from Integer to Long:

Dim i As Integer? = 10
Dim l As Long? = i

변환할 때는 T?S?이면 값 T?Nothing의 값 S? 됩니다 Nothing합니다.When converting from T? to S?, if the value of T? is Nothing, then the value of S? will be Nothing. 변환할 때는 S?T 또는 T?S이면 값 T? 또는 S?Nothing, System.InvalidCastException 예외가 throw 됩니다.When converting from S? to T or T? to S, if the value of T? or S? is Nothing, a System.InvalidCastException exception will be thrown.

기본 형식의 동작으로 인해 System.Nullable(Of T)때 nullable 값 형식 T? 는 결과 box 형식의 boxed 값 T, 형식의 boxed 값이 아닌 T?합니다.Because of the behavior of the underlying type System.Nullable(Of T), when a nullable value type T? is boxed, the result is a boxed value of type T, not a boxed value of type T?. 와 반대로 때 nullable 값 형식으로 unboxing T?, 값 래핑될 System.Nullable(Of T), 및 Nothing 형식의 null 값으로 boxed 됩니다 T?.And, conversely, when unboxing to a nullable value type T?, the value will be wrapped by System.Nullable(Of T), and Nothing will be unboxed to a null value of type T?. 예를 들어:For example:

Dim i1? As Integer = Nothing
Dim o1 As Object = i1

Console.WriteLine(o1 Is Nothing)                    ' Will print True
o1 = 10
i1 = CType(o1, Integer?)
Console.WriteLine(i1)                               ' Will print 10

이 동작의 부작용은는 nullable 값 형식 T? 모두의 인터페이스 구현가 T이므로 값 형식 인터페이스 변환할를 수행 하려면 유형을 넣을.A side effect of this behavior is that a nullable value type T? appears to implement all of the interfaces of T, because converting a value type to an interface requires the type to be boxed. 결과적으로, T? 은 모든 인터페이스를 변환할 수는 T 으로 변환 될 수 있습니다.As a result, T? is convertible to all the interfaces that T is convertible to. 단, null 허용 값을 입력 하는 일을 해야 T? 실제로의 인터페이스를 구현 하지 않는 T 제네릭 제약 조건 검사 또는 리플렉션의 목적입니다.It is important to note, however, that a nullable value type T? does not actually implement the interfaces of T for the purposes of generic constraint checking or reflection. 예를 들어:For example:

Interface I1
End Interface

Structure T1
    Implements I1
    ...
End Structure

Module Test
    Sub M1(Of T As I1)(ByVal x As T)
    End Sub

    Sub Main()
        Dim x? As T1 = Nothing
        Dim y As I1 = x                ' Valid
        M1(x)                          ' Error: x? does not satisfy I1 constraint
    End Sub
End Module

문자열 변환String Conversions

변환 CharString 인 첫 번째 문자는 문자 값을 문자열의 결과입니다.Converting Char into String results in a string whose first character is the character value. 변환 StringChar 값인 문자열의 첫 번째 문자는 문자에 발생 합니다.Converting String into Char results in a character whose value is the first character of the string. 배열을 변환 CharString 인 문자 배열의 요소 문자열에서 발생 합니다.Converting an array of Char into String results in a string whose characters are the elements of the array. 변환 String 배열로 Char 결과 요소가 들어 있는 문자열의 문자는 문자 배열입니다.Converting String into an array of Char results in an array of characters whose elements are the characters of the string.

간의 정확한 변환을 StringBoolean, Byte, SByte, UShortShort, UInteger, Integer, ULongLong, Decimal, Single, Double, Date,이 사양의 범위를 벗어나는 반대로 및 구현을 하나의 세부 정보를 제외 하 고 종속 됩니다.The exact conversions between String and Boolean, Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, Double, Date, and vice versa, are beyond the scope of this specification and are implementation dependent with the exception of one detail. 문자열 변환은 항상 런타임 환경의 현재 문화권을 고려합니다.String conversions always consider the current culture of the run-time environment. 따라서 런타임에 수행 되어야 합니다.As such, they must be performed at run time.

확대 변환Widening Conversions

확대 변환은 오버플로되지 않지만 정밀도 손실 수반 될 수 있습니다.Widening conversions never overflow but may entail a loss of precision. 다음 변환은 확대 변환 합니다.The following conversions are widening conversions:

Identity/기본값 변환Identity/Default conversions

  • 자체에 형식입니다.From a type to itself.

  • 익명 대리자 형식에서 동일한 시그니처가 대리자 형식으로 람다 메서드 재분류 생성 합니다.From an anonymous delegate type generated for a lambda method reclassification to any delegate type with an identical signature.

  • 리터럴에서 Nothing 형식입니다.From the literal Nothing to a type.

숫자 변환Numeric conversions

  • ByteUShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, 또는 Double합니다.From Byte to UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, or Double.

  • SByteShort, Integer, Long, DecimalSingle, 또는 Double합니다.From SByte to Short, Integer, Long, Decimal, Single, or Double.

  • UShortUInteger, Integer, ULong, LongDecimal, Single, 또는 Double합니다.From UShort to UInteger, Integer, ULong, Long, Decimal, Single, or Double.

  • ShortIntegerLong, DecimalSingle 또는 Double합니다.From Short to Integer, Long, Decimal, Single or Double.

  • UIntegerULongLong, DecimalSingle, 또는 Double합니다.From UInteger to ULong, Long, Decimal, Single, or Double.

  • IntegerLong, Decimal합니다 Single 또는 Double합니다.From Integer to Long, Decimal, Single or Double.

  • ULongDecimalSingle, 또는 Double합니다.From ULong to Decimal, Single, or Double.

  • LongDecimal하십시오 Single 또는 Double합니다.From Long to Decimal, Single or Double.

  • DecimalSingle 또는 Double합니다.From Decimal to Single or Double.

  • SingleDouble입니다.From Single to Double.

  • 리터럴에서 0 열거 형식입니다.From the literal 0 to an enumerated type. (참고 합니다.(Note. 변환 0 열거 된 형식으로 테스트 플래그를 간소화 하기 위해 확대 합니다.The conversion from 0 to any enumerated type is widening to simplify testing flags. 경우에 예를 들어 Values 값을 가진 열거형 형식만 One, 변수를 테스트할 수 있습니다 v 형식의 Values 하면 (v And Values.One) = 0.)For example, if Values is an enumerated type with a value One, you could test a variable v of type Values by saying (v And Values.One) = 0.)

  • 기본 숫자 형식으로 확대 변환 된 숫자 형식 또는 해당 기본 숫자 형식, 열거형된 형식입니다.From an enumerated type to its underlying numeric type, or to a numeric type that its underlying numeric type has a widening conversion to.

  • 형식의 상수 식에서 ULong, Long, UInteger, IntegerUShortShort, Byte, 또는 SByte 좁은 형식 내에서 상수 식의 값이 제공 합니다 대상 형식의 범위입니다.From a constant expression of type ULong, Long, UInteger, Integer, UShort, Short, Byte, or SByte to a narrower type, provided the value of the constant expression is within the range of the destination type. (참고 합니다.(Note. 변환할 UInteger 또는 IntegerSingle, ULong 또는 LongSingle 또는 Double, 또는 DecimalSingle 또는 Double 정밀도 손실 될 수 있지만 하지 않음 magnitude의 손실 허용 합니다.Conversions from UInteger or Integer to Single, ULong or Long to Single or Double, or Decimal to Single or Double may cause a loss of precision, but will never cause a loss of magnitude. 다른 확장 숫자 변환 정보가 손실 되지 않도록 모든.)The other widening numeric conversions never lose any information.)

참조 변환Reference conversions

  • 기본 형식으로 사용 되는 참조 형식입니다.From a reference type to a base type.

  • 인터페이스 형식에 대 한 참조 형식에서 variant 호환 인터페이스 또는 인터페이스 형식에서 구현 하는 제공 합니다.From a reference type to an interface type, provided that the type implements the interface or a variant compatible interface.

  • 인터페이스 형식에서 Object합니다.From an interface type to Object.

  • 호환 되는 변형 인터페이스 형식으로 사용 되는 인터페이스 형식입니다.From an interface type to a variant compatible interface type.

  • 호환 되는 variant 대리자 형식에서 대리자 형식입니다.From a delegate type to a variant compatible delegate type. (참고 합니다.(Note. 이러한 규칙에 따라 다른 많은 참조 변환이 포함 됩니다.Many other reference conversions are implied by these rules. 예를 들어 익명 대리자는 참조 형식에서 상속한 System.MulticastDelegate; 배열 형식은 참조 형식에서 상속 되는 System.Array익명; 형식은 참조 형식에서 상속 되는 System.Object.)For example, anonymous delegates are reference types that inherit from System.MulticastDelegate; array types are reference types that inherit from System.Array; anonymous types are reference types that inherit from System.Object.)

익명 대리자 변환Anonymous Delegate conversions

  • 익명 대리자는 람다 메서드 재분류 더 광범위 한 대리자 형식에 대해 생성 된 형식입니다.From an anonymous delegate type generated for a lambda method reclassification to any wider delegate type.

배열 변환Array conversions

  • 배열 형식이 S 요소 형식을 가진 Se 배열 형식으로 T 요소 형식을 가진 Te경우 다음 모두:From an array type S with an element type Se to an array type T with an element type Te, provided all of the following are true:

    • ST 요소 형식에 의해서만 달라 집니다.S and T differ only in element type.

    • 둘 다 SeTe 는 참조 형식 또는 참조 형식으로 알려진 형식 매개 변수입니다.Both Se and Te are reference types or are type parameters known to be a reference type.

    • 확대 참조, 배열 또는 형식에서 매개 변수 변환이 존재 SeTe입니다.A widening reference, array, or type parameter conversion exists from Se to Te.

  • 배열 형식이 S 열거 된 요소 형식을 가진 Se 배열 형식으로 T 요소 형식을 가진 Te경우 다음 모두:From an array type S with an enumerated element type Se to an array type T with an element type Te, provided all of the following are true:

    • ST 요소 형식에 의해서만 달라 집니다.S and T differ only in element type.

    • Te 기본 형식인 Se합니다.Te is the underlying type of Se.

  • 배열 형식에서 S 열거 된 요소 형식 가진 1 순위의 SeSystem.Collections.Generic.IList(Of Te), IReadOnlyList(Of Te)ICollection(Of Te)IReadOnlyCollection(Of Te), 및 IEnumerable(Of Te)다음 중 하나가 true 인 경우:From an array type S of rank 1 with an enumerated element type Se, to System.Collections.Generic.IList(Of Te), IReadOnlyList(Of Te), ICollection(Of Te), IReadOnlyCollection(Of Te), and IEnumerable(Of Te), provided one of the following is true:

    • 둘 다 Se 하 고 Te 는 참조 형식 또는 형식 매개 변수 참조가 되도록 형식 및 확대 참조, 배열, 또는에서 형식 매개 변수 변환이 존재 알려진 Se 하려면 Te; 또는Both Se and Te are reference types or are type parameters known to be a reference type, and a widening reference, array, or type parameter conversion exists from Se to Te; or

    • Te 기본 형식인 Se; 또는Te is the underlying type of Se; or

    • TeSe와 같은 경우Te is identical to Se

값 형식 변환Value Type conversions

  • 기본 형식으로 값 형식입니다.From a value type to a base type.

  • 형식을 구현 하는 인터페이스 형식으로 값 형식입니다.From a value type to an interface type that the type implements.

Nullable 값 형식 변환Nullable Value Type conversions

  • 유형에 서 T 형식으로 T?입니다.From a type T to the type T?.

  • 형식에서 T? 형식으로 S?형식에서 확대 변환이 여기서 T 형식으로 S입니다.From a type T? to a type S?, where there is a widening conversion from the type T to the type S.

  • 형식에서 T 형식으로 S?형식에서 확대 변환이 여기서 T 형식으로 S입니다.From a type T to a type S?, where there is a widening conversion from the type T to the type S.

  • 유형에 서 T? 인터페이스는 입력 형식 T 구현 합니다.From a type T? to an interface type that the type T implements.

문자열 변환String conversions

  • CharString입니다.From Char to String.

  • Char()String입니다.From Char() to String.

형식 매개 변수 변환Type Parameter conversions

  • 형식 매개 변수에서 Object합니다.From a type parameter to Object.

  • 인터페이스 형식 제약 조건 또는 인터페이스 형식 제약 조건에 호환 인터페이스 변형을 형식 매개 변수에서From a type parameter to an interface type constraint or any interface variant compatible with an interface type constraint.

  • 클래스 제약 조건에 의해 구현 된 인터페이스를 형식 매개 변수에서From a type parameter to an interface implemented by a class constraint.

  • 클래스 제약 조건에 의해 구현 된 인터페이스와 호환 되는 인터페이스 변형에 형식 매개 변수에서From a type parameter to an interface variant compatible with an interface implemented by a class constraint.

  • 클래스 제약 조건 또는 기본 클래스 제약 조건 형식에 형식 매개 변수에서From a type parameter to a class constraint, or a base type of the class constraint.

  • 형식 매개 변수에서 T 형식 매개 변수 제약 조건에 Tx, 또는 아무 것도 Tx 확대 변환 했습니다.From a type parameter T to a type parameter constraint Tx, or anything Tx has a widening conversion to.

축소 변환Narrowing Conversions

축소 변환은 축소 표기법을 사용 하기 충분히 서로 다른 형식의 도메인에 걸쳐 항상 성공를 입증할 수 없는 변환, 내용은 손실 될 수도 있는 변환 및 변환 됩니다.Narrowing conversions are conversions that cannot be proved to always succeed, conversions that are known to possibly lose information, and conversions across domains of types sufficiently different to merit narrowing notation. 다음과 같은 변환이 축소 변환으로 분류 됩니다.The following conversions are classified as narrowing conversions:

부울 변환Boolean conversions

  • BooleanByte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, 또는 Double합니다.From Boolean to Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, or Double.

  • Byte, SByte, UShort, Short, UIntegerInteger, ULong, Long, DecimalSingle, 또는 DoubleBoolean입니다.From Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, or Double to Boolean.

숫자 변환Numeric conversions

  • ByteSByte입니다.From Byte to SByte.

  • SByteByteUShortUInteger, 또는 ULong합니다.From SByte to Byte, UShort, UInteger, or ULong.

  • UShortByteSByte, 또는 Short합니다.From UShort to Byte, SByte, or Short.

  • ShortByteSByte, UShortUInteger, 또는 ULong합니다.From Short to Byte, SByte, UShort, UInteger, or ULong.

  • UIntegerByteSByte, UShortShort, 또는 Integer합니다.From UInteger to Byte, SByte, UShort, Short, or Integer.

  • IntegerByte, SByte, UShort, ShortUInteger, 또는 ULong합니다.From Integer to Byte, SByte, UShort, Short, UInteger, or ULong.

  • ULongByte, SByte, UShort, ShortUInteger, Integer, 또는 Long합니다.From ULong to Byte, SByte, UShort, Short, UInteger, Integer, or Long.

  • LongByte, SByte, UShort, ShortUInteger, Integer, 또는 ULong합니다.From Long to Byte, SByte, UShort, Short, UInteger, Integer, or ULong.

  • DecimalByte, SByte, UShort, Short, UInteger, IntegerULong, 또는 Long합니다.From Decimal to Byte, SByte, UShort, Short, UInteger, Integer, ULong, or Long.

  • SingleByte, SByte, UShort, Short, UInteger, Integer, ULong, Long, 또는 Decimal합니다.From Single to Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, or Decimal.

  • DoubleByte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, 또는 Single합니다.From Double to Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, or Single.

  • 열거 된 형식에는 숫자 형식입니다.From a numeric type to an enumerated type.

  • 숫자 형식 열거 형식을 통해 기본 숫자 형식으로 축소 변환을 있습니다.From an enumerated type to a numeric type its underlying numeric type has a narrowing conversion to.

  • 다른 열거형된 형식에는 열거 형식입니다.From an enumerated type to another enumerated type.

참조 변환Reference conversions

  • 더 많이 파생 된 형식에는 참조 형식입니다.From a reference type to a more derived type.

  • 인터페이스 형식으로 클래스 형식에서 클래스 형식에는 인터페이스 형식 또는 인터페이스 형식 변형 호환 구현 하지 않는 제공 합니다.From a class type to an interface type, provided the class type does not implement the interface type or an interface type variant compatible with it.

  • 클래스 형식으로 사용 되는 인터페이스 형식입니다.From an interface type to a class type.

  • 인터페이스에서 다른 인터페이스 형식으로 제공 된 두 형식 간에 상속 관계가 없는 형식과 제공 variant 호환 되지 않습니다.From an interface type to another interface type, provided there is no inheritance relationship between the two types and provided they are not variant compatible.

익명 대리자 변환Anonymous Delegate conversions

  • 모든 더 좁은 대리자 형식으로 람다 메서드 재분류에 대해 생성 하는 익명 대리자 형식입니다.From an anonymous delegate type generated for a lambda method reclassification to any narrower delegate type.

배열 변환Array conversions

  • 배열 형식이 S 요소 형식을 가진 Se, 배열 형식으로 T 요소 형식을 가진 Te다음에 모두 있는 경우:From an array type S with an element type Se, to an array type T with an element type Te, provided that all of the following are true:

    • ST 요소 형식에 의해서만 달라 집니다.S and T differ only in element type.
    • 둘 다 SeTe 는 참조 형식 또는 형식 매개 변수가 알 수 없는 값 형식입니다.Both Se and Te are reference types or are type parameters not known to be value types.
    • 축소 참조, 배열 또는 형식 매개 변수 변환이 존재 SeTe입니다.A narrowing reference, array, or type parameter conversion exists from Se to Te.
  • 배열 형식이 S 요소 형식을 가진 Se 배열 형식으로 T 열거 된 요소 형식을 가진 Te경우 다음 모두:From an array type S with an element type Se to an array type T with an enumerated element type Te, provided all of the following are true:

    • ST 요소 형식에 의해서만 달라 집니다.S and T differ only in element type.
    • Se 기본 형식인 Te , 또는 동일한 기본 형식을 공유 하는 모두 다른 열거형된 형식입니다.Se is the underlying type of Te , or they are both different enumerated types that share the same underlying type.
  • 배열 형식에서 S 열거 된 요소 형식 가진 1 순위의 SeIList(Of Te), IReadOnlyList(Of Te)ICollection(Of Te)IReadOnlyCollection(Of Te)IEnumerable(Of Te)다음 중 하나가 true 인 경우:From an array type S of rank 1 with an enumerated element type Se, to IList(Of Te), IReadOnlyList(Of Te), ICollection(Of Te), IReadOnlyCollection(Of Te) and IEnumerable(Of Te), provided one of the following is true:

    • 둘 다 Se 하 고 Te 는 참조 형식 또는 형식 매개 변수는 참조 형식으로 알려진 및 축소 참조, 배열 또는 형식 매개 변수 변환에서 존재 Se 하려면 Te; 또는Both Se and Te are reference types or are type parameters known to be a reference type, and a narrowing reference, array, or type parameter conversion exists from Se to Te; or
    • Se 기본 형식인 Te, 또는 동일한 기본 형식을 공유 하는 모두 다른 열거형된 형식입니다.Se is the underlying type of Te, or they are both different enumerated types that share the same underlying type.

값 형식 변환Value type conversions

  • 더 많이 파생 된 값 형식에는 참조 형식입니다.From a reference type to a more derived value type.

  • 값 형식에는 인터페이스 형식에서 값 형식 인터페이스 형식을 구현를 제공 합니다.From an interface type to a value type, provided the value type implements the interface type.

Nullable 값 형식 변환Nullable Value Type conversions

  • 유형에 서 T? 형식으로 T입니다.From a type T? to a type T.

  • 유형에 서 T? 형식으로 S?축소 변환 가능한 형식에서 여기서 T 형식으로 S합니다.From a type T? to a type S?, where there is a narrowing conversion from the type T to the type S.

  • 유형에 서 T 형식으로 S?축소 변환 가능한 형식에서 여기서 T 형식으로 S합니다.From a type T to a type S?, where there is a narrowing conversion from the type T to the type S.

  • 유형에 서 S? 형식으로 T형식에서 변환 되 S 형식으로 T입니다.From a type S? to a type T, where there is a conversion from the type S to the type T.

문자열 변환String conversions

  • StringChar입니다.From String to Char.

  • StringChar()입니다.From String to Char().

  • StringBoolean 들어오고 BooleanString입니다.From String to Boolean and from Boolean to String.

  • 간의 변환을 StringByte, SByte, UShort, ShortUInteger, Integer, ULong, LongDecimal, Single, 또는 Double합니다.Conversions between String and Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, or Double.

  • StringDate 들어오고 DateString입니다.From String to Date and from Date to String.

형식 매개 변수 변환Type Parameter conversions

  • Object 형식 매개 변수에 있습니다.From Object to a type parameter.

  • 형식에서 형식 매개 변수를 제공 하는 인터페이스 형식으로 매개 변수 해당 인터페이스에 대 한 제한 또는 인터페이스를 구현 하는 클래스에 제한 됩니다.From a type parameter to an interface type, provided the type parameter is not constrained to that interface or constrained to a class that implements that interface.

  • 형식 매개 변수를 사용 하는 인터페이스 형식입니다.From an interface type to a type parameter.

  • 파생 된 유형의 클래스 제약 조건 형식 매개 변수입니다.From a type parameter to a derived type of a class constraint.

  • 형식 매개 변수에서 T 값 형식 매개 변수 제약 조건으로 Tx 로 축소 변환 했습니다.From a type parameter T to anything a type parameter constraint Tx has a narrowing conversion to.

형식 매개 변수 변환Type Parameter Conversions

형식 매개 변수 변환에 있는 경우, 제약 조건에 의해 결정 됩니다.Type parameters' conversions are determined by the constraints, if any, put on them. 형식 매개 변수 T 항상 변환할 수 자체에서 Object, 그리고 임의의 인터페이스 형식입니다.A type parameter T can always be converted to itself, to and from Object, and to and from any interface type. 경우 종류를 확인 T 런타임에서 변환 시 값 형식이 TObject 또는 인터페이스 형식에서 변환 및 boxing 변환 됩니다 Object 또는 인터페이스 형식 T unboxing 됩니다 변환 합니다.Note that if the type T is a value type at run-time, converting from T to Object or an interface type will be a boxing conversion and converting from Object or an interface type to T will be an unboxing conversion. 클래스 제약 조건이 있는 형식 매개 변수 C 에서 형식 매개 변수를 추가 변환을 정의 C 와 해당 기본 클래스, 그 반대로 가능 합니다.A type parameter with a class constraint C defines additional conversions from the type parameter to C and its base classes, and vice versa. 형식 매개 변수 T 형식 매개 변수 제약 조건을 Tx 으로 변환을 정의 Tx 고 아무 것도 Tx 변환 합니다.A type parameter T with a type parameter constraint Tx defines a conversion to Tx and anything Tx converts to.

요소 형식이 인터페이스 제약 조건 사용 하 여 형식 매개 변수 배열을 I 가지 며 요소 형식이 배열로 동일한 공변 (covariant) 배열 변환에 I제공 하는 형식 매개 변수 역시는 Class 또는 제약 조건 (클래스 배열 요소 형식 에서만 참조 될 수 있으므로 공변 (covariant)).An array whose element type is a type parameter with an interface constraint I has the same covariant array conversions as an array whose element type is I, provided that the type parameter also has a Class or class constraint (since only reference array element types can be covariant). 요소 형식이 형식 매개 변수는 클래스 제약 조건이 배열을 C 동일한 공변 (covariant) 배열 변환이 가지 며 요소 형식이 배열에 C입니다.An array whose element type is a type parameter with a class constraint C has the same covariant array conversions as an array whose element type is C.

위의 변환 규칙을 허용 하지 않습니다 인터페이스가 아닌 형식으로 제한 되지 않은 형식 매개 변수에서 변환 놀라울 수 있지만.The above conversions rules do not permit conversions from unconstrained type parameters to non-interface types, which may be surprising. 이유 이러한 변환의 의미 체계에 대 한 혼동을 방지 하는 것입니다.The reason for this is to prevent confusion about the semantics of such conversions. 예를 들어, 다음 선언을 참조하십시오.For example, consider the following declaration:

Class X(Of T)
    Public Shared Function F(t As T) As Long 
        Return CLng(t)    ' Error, explicit conversion not permitted
    End Function
End Class

경우 변환 TInteger 쉽게 예상할 수 허용 되는 X(Of Integer).F(7) 반환 7L합니다.If the conversion of T to Integer were permitted, one might easily expect that X(Of Integer).F(7) would return 7L. 그러나 것 하지 형식이 컴파일 타임에 숫자 것으로 알려진 경우에 숫자 변환 간주 되기 때문에 있습니다.However, it would not, because numeric conversions are only considered when the types are known to be numeric at compile time. 의미 체계를 확인 하기 위해 명확 하 고 위의 예제에서는 대신 써야 합니다.In order to make the semantics clear, the above example must instead be written:

Class X(Of T)
    Public Shared Function F(t As T) As Long
        Return CLng(CObj(t))    ' OK, conversions permitted
    End Function
End Class

사용자 정의 변환User-Defined Conversions

내장 변환을 하는 동안 (즉,이 사양)에 나열 하는 언어에서 정의 된 변환은 사용자 정의 변환은 오버 로드 하 여 정의 된는 CType 연산자.Intrinsic conversions are conversions defined by the language (i.e. listed in this specification), while user-defined conversions are defined by overloading the CType operator. 해당 내장 변환이 없으면 형식 간에 변환 하는 경우 사용자 정의 변환은 고려 됩니다.When converting between types, if no intrinsic conversions are applicable then user-defined conversions will be considered. 경우는 사용자 정의 변환이 있기 가장 구체적인 원본 및 대상 형식에 대 한 다음 사용자 정의 변환 됩니다.If there is a user-defined conversion that is most specific for the source and target types, then the user-defined conversion will be used. 그렇지 않으면 컴파일 타임 오류가 발생합니다.Otherwise, a compile-time error results. 가장 구체적인 변환은 해당 피연산자가 원본 형식으로 "가장 가까운"과 결과 형식이 가장 "가까운"을 대상 형식입니다.The most specific conversion is the one whose operand is "closest" to the source type and whose result type is "closest" to the target type. 사용 하는 사용자 정의 변환이 결정할 때 가장 구체적인 확대 변환이 사용 됩니다. 없는 확대 변환이 가장 구체적인 가장 구체적인 축소 변환 됩니다.When determining what user-defined conversion to use, the most specific widening conversion will be used; if no widening conversion is most specific, the most specific narrowing conversion will be used. 이상 가장 구체적인 축소 변환에 있으면 다음 변환이 정의 되지 않습니다 및 컴파일 타임 오류가 발생 합니다.If there is no most specific narrowing conversion, then the conversion is undefined and a compile-time error occurs.

다음 섹션에서는 가장 특정 변환의 결정 방식을 설명 합니다.The following sections cover how the most specific conversions are determined. 다음 조건에 사용합니다.They use the following terms:

형식에서 변환이 내장 함수를 확대 하는 경우 A 형식으로 B, 모두 및 AB 있다면 인터페이스 A롤포워드되지B, 및 B 포괄 A합니다.If an intrinsic widening conversion exists from a type A to a type B, and if neither A nor B are interfaces, then A is encompassed by B, and B encompasses A.

합니다 최상위 형식 집합에서 형식 집합에 다른 모든 형식을 포함 하는 형식입니다.The most encompassing type in a set of types is the one type that encompasses all other types in the set. 다른 모든 형식을 포함 하는 단일 형식이 없는, 하는 경우 집합에 최상위 형식이 없습니다.If no single type encompasses all other types, then the set has no most encompassing type. 직관적인 관점에서 최상위 형식 "큰"의 형식인 set--확대 변환을 통해 변환 되어야 다른 형식의 각 하는 형식입니다.In intuitive terms, the most encompassing type is the "largest" type in the set -- the one type to which each of the other types can be converted through a widening conversion.

합니다 포함 된 가장 형식 집합에서 형식 집합을 다른 모든 형식이 포함 되는 형식입니다.The most encompassed type in a set of types is the one type that is encompassed by all other types in the set. 단일 형식이 없는 다른 모든 형식으로 롤포워드되지 않았습니다, 경우 집합에는 형식 가장 하지 않습니다 포함 했습니다.If no single type is encompassed by all other types, then the set has no most encompassed type. 직관적인 말해 최하위 유형 집합-각 축소 변환을 통해 다른 형식으로 변환 될 수는 형식에에서 "작은" 형식이입니다.In intuitive terms, the most encompassed type is the "smallest" type in the set -- the one type that can be converted to each of the other types through a narrowing conversion.

형식에 대 한 사용자 정의 변환 후보를 수집 하는 경우 T?, 사용자 정의 변환 연산자는 정의한 T 대신 사용 됩니다.When collecting the candidate user-defined conversions for a type T?, the user-defined conversion operators defined by T are used instead. 변환할 대상 형식을 nullable 값 형식이 면 다음 중 하나 이기도 한 경우 T의 사용자 정의 형식만 nullable이 아닌 값을 포함 하는 변환 연산자는 적용 되지 않습니다.If the type being converted to is also a nullable value type, then any of T's user-defined conversions operators that involve only non-nullable value types are lifted. 변환 연산자 TS 으로 변환 되도록 리프트 T?S? 변환 하 여 계산 됩니다 T?T사용자 정의 변환이 평가 하는 다음에 필요한 경우 연산자 TS 을 만든 다음 변환 SS?필요한 경우.A conversion operator from T to S is lifted to be a conversion from T? to S? and is evaluated by converting T? to T, if necessary, then evaluating the user-defined conversion operator from T to S and then converting S to S?, if necessary. 그러나 변환 되는 값 이면 Nothing, 리프팅된 변환 연산자의 값으로 직접 변환 되는 Nothing 로 형식화 된 S?합니다.If the value being converted is Nothing, however, a lifted conversion operator converts directly into a value of Nothing typed as S?. 예를 들어:For example:

Structure S
    ...
End Structure

Structure T
    Public Shared Widening Operator CType(ByVal v As T) As S
        ...
    End Operator
End Structure

Module Test
    Sub Main()
        Dim x As T?
        Dim y As S?

        y = x                ' Legal: y is still null
        x = New T()
        y = x                ' Legal: Converts from T to S
    End Sub
End Module

변환 해결 사용자 정의 변환 연산자는 항상 기본 리프트 변환 연산자를 통해입니다.When resolving conversions, user-defined conversions operators are always preferred over lifted conversion operators. 예를 들어:For example:

Structure S
    ...
End Structure

Structure T
    Public Shared Widening Operator CType(ByVal v As T) As S
        ...
    End Operator

    Public Shared Widening Operator CType(ByVal v As T?) As S?
        ...
    End Operator
End Structure

Module Test
    Sub Main()
        Dim x As T?
        Dim y As S?

        y = x                ' Calls user-defined conversion, not lifted conversion
    End Sub
End Module

런타임에, 사용자 정의 변환이 평가 최대 3 개의 단계 포함할 수 있습니다.At run-time, evaluating a user-defined conversion can involve up to three steps:

  1. 먼저 값 소스 형식에서 변환 하는 내장 변환을 사용 하 여 필요한 경우 피연산자 형식으로 변환 됩니다.First, the value is converted from the source type to the operand type using an intrinsic conversion, if necessary.

  2. 그런 다음 사용자 정의 변환이 호출 됩니다.Then, the user-defined conversion is invoked.

  3. 마지막으로, 필요한 경우 사용자 정의 변환의 결과 내장 함수는 변환을 사용 하 여 대상 형식으로 변환 됩니다.Finally, the result of the user-defined conversion is converted to the target type using an intrinsic conversion, if necessary.

사용자 정의 변환의 평가 둘 이상의 사용자 정의 변환 연산자와 관련 되지를 확인 하는 것이 반드시 합니다.It is important to note that evaluation of a user-defined conversion will never involve more than one user-defined conversion operator.

가장 구체적인 확대 변환Most Specific Widening Conversion

가장 구체적인 사용자 정의 확대 변환 연산자 두 형식 간에 확인 단계를 사용 하 여 수행 됩니다.Determining the most specific user-defined widening conversion operator between two types is accomplished using the following steps:

  1. 먼저 모든 후보 변환 연산자 수집 됩니다.First, all of the candidate conversion operators are collected. 변환 연산자는 후보는 모든 확대 변환이 사용자 정의 연산자 된 소스 형식의 및 확대 변환 사용자 정의 연산자를 대상 형식으로의 모든입니다.The candidate conversion operators are all of the user-defined widening conversion operators in the source type and all of the user-defined widening conversion operators in the target type.

  2. 그런 다음 모든 적합 하지 않은 변환 연산자는 집합에서 제거 됩니다.Then, all non-applicable conversion operators are removed from the set. 내장 확대 변환 연산자가 원본 유형에 서 피연산자 형식으로 되어 내장 확대 변환 연산자를 연산자의 결과에서 대상 형식으로 변환 연산자를 원본 형식 및 대상 형식에 적용 됩니다.A conversion operator is applicable to a source type and target type if there is an intrinsic widening conversion operator from the source type to the operand type and there is an intrinsic widening conversion operator from the result of the operator to the target type. 해당 변환 연산자의 경우 다음 경우 이상 가장 구체적인 확대 변환If there are no applicable conversion operators, then there is no most specific widening conversion.

  3. 그런 다음 해당 변환 연산자의 가장 구체적인 원본 유형이 결정 됩니다.Then, the most specific source type of the applicable conversion operators is determined:

    • 소스 형식에서 직접 변환 하는 변환 연산자 중 하나를 원본 유형을 경우 가장 구체적인 소스 형식입니다.If any of the conversion operators convert directly from the source type, then the source type is the most specific source type.

    • 그렇지 않으면 가장 구체적인 원본 유형 소스 형식의 변환 연산자의 조합된 된 집합의 최하위 형식이입니다.Otherwise, the most specific source type is the most encompassed type in the combined set of source types of the conversion operators. 가장 포함 되지 않은 경우 형식을 찾을 수를 더 가장 구체적인 확대 변환 합니다.If no most encompassed type can be found, then there is no most specific widening conversion.

  4. 그런 다음 해당 변환 연산자의 가장 구체적인 대상 형식이 결정 됩니다.Then, the most specific target type of the applicable conversion operators is determined:

    • 변환 연산자 중 하나가 대상 형식으로 직접 변환, 대상 형식의 경우 가장 구체적인 대상 형식입니다.If any of the conversion operators convert directly to the target type, then the target type is the most specific target type.

    • 그렇지 않으면 가장 구체적인 대상 유형 대상 형식의 변환 연산자의 조합된 된 집합에서 최상위 형식이입니다.Otherwise, the most specific target type is the most encompassing type in the combined set of target types of the conversion operators. 최상위 형식을 찾을 수 있는 경우 더 가장 구체적인 확대 변환 합니다.If no most encompassing type can be found, then there is no most specific widening conversion.

  5. 그런 다음 정확히 하나의 변환 연산자 가장 구체적인 원본 유형에 서 가장 구체적인 대상 형식으로 변환,이 경우 가장 구체적인 변환 연산자입니다.Then, if exactly one conversion operator converts from the most specific source type to the most specific target type, then this is the most specific conversion operator. 이러한 연산자를 둘 이상 있는 경우 다음 변환이 없습니다 가장 구체적인 확대 합니다.If more than one such operator exists, then there is no most specific widening conversion.

가장 구체적인 축소 변환Most Specific Narrowing Conversion

가장 구체적인 사용자 정의 축소 변환 연산자 두 형식 간에 확인 단계를 사용 하 여 수행 됩니다.Determining the most specific user-defined narrowing conversion operator between two types is accomplished using the following steps:

  1. 먼저 모든 후보 변환 연산자 수집 됩니다.First, all of the candidate conversion operators are collected. 변환 연산자는 후보는 모든 소스 형식의 사용자 정의 변환 연산자 및 모든 대상 형식으로 사용자 정의 변환 연산자입니다.The candidate conversion operators are all of the user-defined conversion operators in the source type and all of the user-defined conversion operators in the target type.

  2. 그런 다음 모든 적합 하지 않은 변환 연산자는 집합에서 제거 됩니다.Then, all non-applicable conversion operators are removed from the set. 변환 연산자는 피연산자 형식으로 원본 유형에 서 않은 내장 변환 연산자가 되어 대상 형식으로 연산자의 결과에서 내장 함수 변환 연산자는 소스 형식과 대상 유형 적용 됩니다.A conversion operator is applicable to a source type and target type if there is an intrinsic conversion operator from the source type to the operand type and there is an intrinsic conversion operator from the result of the operator to the target type. 해당 변환 연산자의 경우 다음 변환이 없습니다 가장 구체적인 축소 합니다.If there are no applicable conversion operators, then there is no most specific narrowing conversion.

  3. 그런 다음 해당 변환 연산자의 가장 구체적인 원본 유형이 결정 됩니다.Then, the most specific source type of the applicable conversion operators is determined:

    • 소스 형식에서 직접 변환 하는 변환 연산자 중 하나를 원본 유형을 경우 가장 구체적인 소스 형식입니다.If any of the conversion operators convert directly from the source type, then the source type is the most specific source type.

    • 이 고, 그렇지 원본 유형을 포함 하는 형식에서 변환할 변환 연산자 중 하나가 가장 구체적인 원본 유형이입니다 원본 유형의 이러한 변환 연산자의 조합된 된 집합의 최하위 형식.Otherwise, if any of the conversion operators convert from types that encompass the source type, then the most specific source type is the most encompassed type in the combined set of source types of those conversion operators. 가장 포함 되지 않은 경우 형식을 찾을 수, 가장 구체적인 없는 축소 변환 됩니다.If no most encompassed type can be found, then there is no most specific narrowing conversion.

    • 그렇지 않으면 가장 구체적인 원본 유형 소스 형식의 변환 연산자의 조합된 된 집합에서 최상위 형식이입니다.Otherwise, the most specific source type is the most encompassing type in the combined set of source types of the conversion operators. 최상위 형식이 없는 찾을 수 있는 경우 다음 변환이 없습니다 가장 구체적인 축소 합니다.If no most encompassing type can be found, then there is no most specific narrowing conversion.

  4. 그런 다음 해당 변환 연산자의 가장 구체적인 대상 형식이 결정 됩니다.Then, the most specific target type of the applicable conversion operators is determined:

    • 변환 연산자 중 하나가 대상 형식으로 직접 변환, 대상 형식의 경우 가장 구체적인 대상 형식입니다.If any of the conversion operators convert directly to the target type, then the target type is the most specific target type.

    • 그렇지 않으면 변환 연산자 중 하나가 대상 형식으로 포함 된 형식으로 변환할 경우 가장 구체적인 대상 유형이입니다 원본 유형의 이러한 변환 연산자의 조합된 된 집합에서 최상위 형식.Otherwise, if any of the conversion operators convert to types that are encompassed by the target type, then the most specific target type is the most encompassing type in the combined set of source types of those conversion operators. 최상위 형식이 없는 찾을 수 있는 경우 다음 변환이 없습니다 가장 구체적인 축소 합니다.If no most encompassing type can be found, then there is no most specific narrowing conversion.

    • 그렇지 않으면 가장 구체적인 대상 유형 대상 형식의 변환 연산자의 조합된 된 집합의 최하위 형식이입니다.Otherwise, the most specific target type is the most encompassed type in the combined set of target types of the conversion operators. 가장 포함 되지 않은 경우 형식을 찾을 수, 가장 구체적인 없는 축소 변환 됩니다.If no most encompassed type can be found, then there is no most specific narrowing conversion.

  5. 그런 다음 정확히 하나의 변환 연산자 가장 구체적인 원본 유형에 서 가장 구체적인 대상 형식으로 변환,이 경우 가장 구체적인 변환 연산자입니다.Then, if exactly one conversion operator converts from the most specific source type to the most specific target type, then this is the most specific conversion operator. 이러한 연산자를 둘 이상 있는 경우 다음 변환이 없습니다 가장 구체적인 축소 합니다.If more than one such operator exists, then there is no most specific narrowing conversion.

기본 변환Native Conversions

로 분류 된 다양 한 변환을 기본 변환 .NET Framework에서 고유 하 게 지원 합니다.Several of the conversions are classified as native conversions because they are supported natively by the .NET Framework. 이러한 변환은 사용 하 여 최적화할 수 있는 것을 DirectCastTryCast 변환 연산자 뿐만 아니라 다른 특별 한 동작입니다.These conversions are ones that can be optimized through the use of the DirectCast and TryCast conversion operators, as well as other special behaviors. 기본 변환으로 분류 하는 변환을: identity 변환, 기본 변환, 참조 변환, 배열 변환, 값 형식 변환 및 형식 매개 변수 변환 합니다.The conversions classified as native conversions are: identity conversions, default conversions, reference conversions, array conversions, value type conversions, and type parameter conversions.

기준 형식Dominant Type

형식의 집합을 지정 하는 경우가 결정 하는 형식 유추와 같은 경우에는 기준 형식 집합.Given a set of types, it is often necessary in situations such as type inference to determine the dominant type of the set. 첫 번째 하나 이상의 다른 형식으로 암시적 변환이 없는 형식을 제거 하 여 형식 집합이의 지배적인 유형이 결정 됩니다.The dominant type of a set of types is determined by first removing any types that one or more other types do not have an implicit conversion to. 유형이 없습니다 왼쪽이 시점에서, 인지 지배적인 유형이 없습니다.If there are no types left at this point, there is no dominant type. 기준 형식에 있으면 가장 나머지 형식 포함.The dominant type is then the most encompassed of the remaining types. 입력이 둘 이상 있으면 가장 롤포워드되지 않았습니다를 다음 기준 형식이 없습니다.If there is more than one type that is most encompassed, then there is no dominant type.