Type.GenericParameterPosition Property

Definition

Type 개체가 제네릭 형식이나 제네릭 메서드의 형식 매개 변수를 나타내는 경우, 해당 매개 변수가 선언된 제네릭 형식 또는 메서드의 형식 매개 변수 목록에서 해당 형식 매개 변수가 있는 위치를 가져옵니다.Gets the position of the type parameter in the type parameter list of the generic type or method that declared the parameter, when the Type object represents a type parameter of a generic type or a generic method.

public:
 abstract property int GenericParameterPosition { int get(); };
public:
 virtual property int GenericParameterPosition { int get(); };
public abstract int GenericParameterPosition { get; }
public virtual int GenericParameterPosition { get; }
member this.GenericParameterPosition : int
Public MustOverride ReadOnly Property GenericParameterPosition As Integer
Public Overridable ReadOnly Property GenericParameterPosition As Integer

Property Value

Int32

형식 매개 변수가 정의된 제네릭 형식 또는 메서드의 형식 매개 변수 목록에서 해당 형식 매개 변수가 있는 위치입니다.The position of a type parameter in the type parameter list of the generic type or method that defines the parameter. 위치 번호는 0부터 시작합니다.Position numbers begin at 0.

Exceptions

현재 형식이 형식 매개 변수를 나타내지 않습니다.The current type does not represent a type parameter. 즉, IsGenericParameterfalse를 반환합니다.That is, IsGenericParameter returns false.

Examples

다음 예제에서는 두 형식 매개 변수를 사용 하 여 제네릭 클래스를 정의 하 고 첫 번째 클래스에서 파생 되는 두 번째 제네릭 클래스를 정의 합니다.The following example defines a generic class with two type parameters and defines a second generic class that derives from the first class. 파생 클래스의 기본 클래스에는 두 개의 형식 인수가 있습니다. 첫 번째는 Int32이 고, 두 번째는 파생 형식의 형식 매개 변수입니다.The derived class's base class has two type arguments: the first is Int32, and the second is a type parameter of the derived type. 이 예제에서는 GenericParameterPosition 속성이 보고 하는 위치를 비롯 하 여 이러한 제네릭 클래스에 대 한 정보를 표시 합니다.The example displays information about these generic classes, including the positions reported by the GenericParameterPosition property.

using namespace System;
using namespace System::Reflection;
using namespace System::Collections::Generic;

// Define a base class with two type parameters.
generic< class T,class U >
public ref class Base {};

// Define a derived class. The derived class inherits from a constructed
// class that meets the following criteria:
//   (1) Its generic type definition is Base<T, U>.
//   (2) It specifies int for the first type parameter.
//   (3) For the second type parameter, it uses the same type that is used
//       for the type parameter of the derived class.
// Thus, the derived class is a generic type with one type parameter, but
// its base class is an open constructed type with one type argument and
// one type parameter.
generic<class V>
public ref class Derived : Base<int,V> {};

public ref class Test
{
public:
    static void Main()
    {
        Console::WriteLine( 
            L"\r\n--- Display a generic type and the open constructed");
        Console::WriteLine(L"    type from which it is derived.");
      
        // Create a Type object representing the generic type definition
        // for the Derived type. Note the absence of type arguments.
        //
        Type^ derivedType = Derived::typeid;
        DisplayGenericTypeInfo(derivedType);
      
        // Display its open constructed base type.
        DisplayGenericTypeInfo(derivedType->BaseType);
    }


private:
    static void DisplayGenericTypeInfo(Type^ t)
    {
        Console::WriteLine(L"\r\n{0}", t);
        Console::WriteLine(L"\tIs this a generic type definition? {0}",
            t->IsGenericTypeDefinition);
        Console::WriteLine(L"\tIs it a generic type? {0}", t->IsGenericType);
        Console::WriteLine(L"\tDoes it have unassigned generic parameters? {0}",
            t->ContainsGenericParameters);
        if (t->IsGenericType)
        {
         
            // If this is a generic type, display the type arguments.
            //
            array<Type^>^typeArguments = t->GetGenericArguments();
            Console::WriteLine(L"\tList type arguments ({0}):",
                typeArguments->Length);
            System::Collections::IEnumerator^ myEnum = 
                typeArguments->GetEnumerator();
            while (myEnum->MoveNext())
            {
                Type^ tParam = safe_cast<Type^>(myEnum->Current);
            
                // IsGenericParameter is true only for generic type
                // parameters.
                //
                if (tParam->IsGenericParameter)
                {
                    Console::WriteLine( 
                        L"\t\t{0}  (unassigned - parameter position {1})", 
                        tParam, tParam->GenericParameterPosition);
                }
                else
                {
                    Console::WriteLine(L"\t\t{0}", tParam);
                }
            }
        }
    }
};

int main()
{
    Test::Main();
}

/* This example produces the following output:

--- Display a generic type and the open constructed
    type from which it is derived.

Derived`1[V]
        Is this a generic type definition? True
        Is it a generic type? True
        Does it have unassigned generic parameters? True
        List type arguments (1):
                V  (unassigned - parameter position 0)

Base`2[System.Int32,V]
        Is this a generic type definition? False
        Is it a generic type? True
        Does it have unassigned generic parameters? True
        List type arguments (2):
                System.Int32
                V  (unassigned - parameter position 0)
 */
using System;
using System.Reflection;
using System.Collections.Generic;

// Define a base class with two type parameters.
public class Base<T, U> { }

// Define a derived class. The derived class inherits from a constructed
// class that meets the following criteria:
//   (1) Its generic type definition is Base<T, U>.
//   (2) It specifies int for the first type parameter.
//   (3) For the second type parameter, it uses the same type that is used
//       for the type parameter of the derived class.
// Thus, the derived class is a generic type with one type parameter, but
// its base class is an open constructed type with one type argument and
// one type parameter.
public class Derived<V> : Base<int, V> { }

public class Test
{
    public static void Main()
    {
        Console.WriteLine(
            "\r\n--- Display a generic type and the open constructed");
        Console.WriteLine("    type from which it is derived.");

        // Create a Type object representing the generic type definition 
        // for the Derived type, by omitting the type argument. (For
        // types with multiple type parameters, supply the commas but
        // omit the type arguments.) 
        //
        Type derivedType = typeof(Derived<>);
        DisplayGenericTypeInfo(derivedType);

        // Display its open constructed base type.
        DisplayGenericTypeInfo(derivedType.BaseType);
    }

    private static void DisplayGenericTypeInfo(Type t)
    {
        Console.WriteLine("\r\n{0}", t);

        Console.WriteLine("\tIs this a generic type definition? {0}", 
            t.IsGenericTypeDefinition);

        Console.WriteLine("\tIs it a generic type? {0}", 
            t.IsGenericType);

        Console.WriteLine("\tDoes it have unassigned generic parameters? {0}", 
            t.ContainsGenericParameters);

        if (t.IsGenericType)
        {
            // If this is a generic type, display the type arguments.
            //
            Type[] typeArguments = t.GetGenericArguments();

            Console.WriteLine("\tList type arguments ({0}):", 
                typeArguments.Length);

            foreach (Type tParam in typeArguments)
            {
                // IsGenericParameter is true only for generic type
                // parameters.
                //
                if (tParam.IsGenericParameter)
                {
                    Console.WriteLine(
                        "\t\t{0}  (unassigned - parameter position {1})",
                        tParam,
                        tParam.GenericParameterPosition);
                }
                else
                {
                    Console.WriteLine("\t\t{0}", tParam);
                }
            }
        }
    }
}

/* This example produces the following output:

--- Display a generic type and the open constructed
    type from which it is derived.

Derived`1[V]
        Is this a generic type definition? True
        Is it a generic type? True
        Does it have unassigned generic parameters? True
        List type arguments (1):
                V  (unassigned - parameter position 0)

Base`2[System.Int32,V]
        Is this a generic type definition? False
        Is it a generic type? True
        Does it have unassigned generic parameters? True
        List type arguments (2):
                System.Int32
                V  (unassigned - parameter position 0)
 */
Imports System.Reflection
Imports System.Collections.Generic

' Define a base class with two type parameters.
Public Class Base(Of T, U)
End Class

' Define a derived class. The derived class inherits from a constructed
' class that meets the following criteria:
'   (1) Its generic type definition is Base<T, U>.
'   (2) It uses int for the first type parameter.
'   (3) For the second type parameter, it uses the same type that is used
'       for the type parameter of the derived class.
' Thus, the derived class is a generic type with one type parameter, but
' its base class is an open constructed type with one assigned type
' parameter and one unassigned type parameter.
Public Class Derived(Of V)
    Inherits Base(Of Integer, V)
End Class

Public Class Test
    
    Public Shared Sub Main() 
        Console.WriteLine(vbCrLf _
            & "--- Display a generic type and the open constructed")
        Console.WriteLine("    type from which it is derived.")
        
        ' Create a Type object representing the generic type definition 
        ' for the Derived type, by omitting the type argument. (For
        ' types with multiple type parameters, supply the commas but
        ' omit the type arguments.) 
        '
        Dim derivedType As Type = GetType(Derived(Of ))
        DisplayGenericTypeInfo(derivedType)
        
        ' Display its open constructed base type.
        DisplayGenericTypeInfo(derivedType.BaseType)
    
    End Sub
    
    Private Shared Sub DisplayGenericTypeInfo(ByVal t As Type) 
        Console.WriteLine(vbCrLf & "{0}", t)
        
        Console.WriteLine(vbTab & "Is this a generic type definition? " _
            & t.IsGenericTypeDefinition)
        
        Console.WriteLine(vbTab & "Is it a generic type? " _
            & t.IsGenericType)
        
        Console.WriteLine(vbTab _
            & "Does it have unassigned generic parameters? " _
            & t.ContainsGenericParameters)
        
        If t.IsGenericType Then
            ' If this is a generic type, display the type arguments.
            '
            Dim typeArguments As Type() = t.GetGenericArguments()
            
            Console.WriteLine(vbTab & "List type arguments (" _
                & typeArguments.Length & "):")
            
            For Each tParam As Type In typeArguments
                ' IsGenericParameter is true only for generic type
                ' parameters.
                '
                If tParam.IsGenericParameter Then
                    Console.WriteLine(vbTab & vbTab & tParam.ToString() _
                        & "  (unassigned - parameter position " _
                        & tParam.GenericParameterPosition & ")")
                Else
                    Console.WriteLine(vbTab & vbTab & tParam.ToString())
                End If
            Next tParam
        End If
    
    End Sub
End Class

' This example produces the following output:
'
'--- Display a generic type and the open constructed
'    type from which it is derived.
'
'Derived`1[V]
'        Is this a generic type definition? True
'        Is it a generic type? True
'        Does it have unassigned generic parameters? True
'        List type arguments (1):
'                V  (unassigned - parameter position 0)
'
'Base`2[System.Int32,V]
'        Is this a generic type definition? False
'        Is it a generic type? True
'        Does it have unassigned generic parameters? True
'        List type parameters (2):
'                System.Int32
'                V  (unassigned - parameter position 0)
' 

Remarks

GenericParameterPosition 속성은 형식 매개 변수가 원래 정의 된 제네릭 형식 정의 또는 제네릭 메서드 정의의 매개 변수 목록에서 형식 매개 변수의 위치를 반환 합니다.The GenericParameterPosition property returns the position of a type parameter in the parameter list of the generic type definition or generic method definition where the type parameter was originally defined. DeclaringTypeDeclaringMethod 속성은 제네릭 형식 또는 메서드 정의를 식별 합니다.The DeclaringType and DeclaringMethod properties identify the generic type or method definition:

  • DeclaringMethod 속성이 MethodInfo를 반환 하는 경우 해당 MethodInfo 제네릭 메서드 정의를 나타내며 현재 Type 개체는 해당 제네릭 메서드 정의의 형식 매개 변수를 나타냅니다.If the DeclaringMethod property returns a MethodInfo, that MethodInfo represents a generic method definition, and the current Type object represents a type parameter of that generic method definition.

  • DeclaringMethod 속성이 null를 반환 하는 경우 DeclaringType 속성은 항상 제네릭 형식 정의를 나타내는 Type 개체를 반환 하 고, 현재 Type 개체는 제네릭 형식 정의의 형식 매개 변수를 나타냅니다.If the DeclaringMethod property returns null, then the DeclaringType property always returns a Type object representing a generic type definition, and the current Type object represents a type parameter of that generic type definition.

GenericParameterPosition 속성의 값에 대 한 올바른 컨텍스트를 제공 하려면 형식 매개 변수가 속한 제네릭 형식 또는 메서드를 식별 해야 합니다.To provide the correct context for the value of the GenericParameterPosition property, it is necessary to identify the generic type or method a type parameter belongs to. 예를 들어 다음 코드에서는 제네릭 메서드의 반환 값을 GetSomething 합니다.For example, consider the return value of the generic method GetSomething in the following code:

generic<typename T, typename U> public ref class B { };
generic<typename V> public ref class A
{
public:
    generic<typename X> B<V, X>^ GetSomething()
    {
        return gcnew B<V, X>();
    }
};
public class B<T, U> { }
public class A<V>
{
    public B<V, X> GetSomething<X>()
    {
        return new B<V, X>();
    }
}
Public Class B(Of T, U)
End Class
Public Class A(Of V)
    Public Function GetSomething(Of X)() As B(Of V, X)
        Return New B(Of V, X)()
    End Function
End Class

GetSomething에서 반환 하는 형식은 클래스 A에 제공 된 형식 인수 및 자체 GetSomething에 따라 달라 집니다.The type returned by GetSomething depends on the type arguments supplied to class A and to GetSomething itself. GetSomething에 대 한 MethodInfo를 가져오고 반환 형식을 가져올 수 있습니다.You can obtain a MethodInfo for GetSomething, and from that you can obtain the return type. 반환 형식의 형식 매개 변수를 검사 하는 경우 GenericParameterPosition는 둘 다에 대해 0을 반환 합니다.When you examine the type parameters of the return type, GenericParameterPosition returns 0 for both. V는 클래스 A의 형식 매개 변수 목록에 있는 첫 번째 형식 매개 변수 이므로 V의 위치는 0입니다.The position of V is 0 because V is the first type parameter in the type parameter list for class A. XGetSomething에 대 한 형식 매개 변수 목록의 첫 번째 형식 매개 변수 이므로 X의 위치는 0입니다.The position of X is 0 because X is the first type parameter in the type parameter list for GetSomething.

Note

현재 Type에서 형식 매개 변수를 나타내지 않는 경우 GenericParameterPosition 속성을 호출 하면 예외가 발생 합니다.Calling the GenericParameterPosition property causes an exception if the current Type does not represent a type parameter. 개방형 생성 형식의 형식 인수를 검사 하는 경우 IsGenericParameter 속성을 사용 하 여 형식 매개 변수 및 형식에 대 한 정보를 확인할 수 있습니다.When you examine the type arguments of an open constructed type, use the IsGenericParameter property to tell which are type parameters and which are types. IsGenericParameter 속성은 형식 매개 변수에 대 한 true를 반환 합니다. 그런 다음 GenericParameterPosition 메서드를 사용 하 여 해당 위치를 가져오고 DeclaringMethodDeclaringType 속성을 사용 하 여이를 정의 하는 제네릭 메서드 또는 형식 정의를 결정할 수 있습니다.The IsGenericParameter property returns true for a type parameter; you can then use the GenericParameterPosition method to obtain its position and use the DeclaringMethod and DeclaringType properties to determine the generic method or type definition that defines it.

Applies to

See also