Type.GenericParameterPosition プロパティ

定義

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:
 virtual property int GenericParameterPosition { int get(); };
public virtual int GenericParameterPosition { get; }
member this.GenericParameterPosition : int
Public Overridable ReadOnly Property GenericParameterPosition As Integer

プロパティ値

パラメーターを定義するジェネリック型またはジェネリック メソッドの型パラメーター リスト内の型パラメーターの位置。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.

例外

現在の型は型パラメーターを表していません。The current type does not represent a type parameter. つまり、IsGenericParameterfalse を返します。That is, IsGenericParameter returns false.

次の例では、2つの型パラメーターを持つジェネリッククラスを定義し、最初のクラスから派生する2番目のジェネリッククラスを定義します。The following example defines a generic class with two type parameters and defines a second generic class that derives from the first class. 派生クラスの基底クラスには、2つの型引数があります。1つ目は Int32で、2つ目は派生型の型パラメーターです。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)
' 

注釈

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. DeclaringType プロパティと DeclaringMethod プロパティは、ジェネリック型またはメソッドの定義を識別します。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. GetSomethingMethodInfo を取得できます。また、戻り値の型を取得できます。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 の位置は0です。これは V がクラス Aの型パラメーターリストの最初の型パラメーターであるためです。The position of V is 0 because V is the first type parameter in the type parameter list for class A. X の位置は0です。これは、XGetSomethingの型パラメーターリストの最初の型パラメーターであるためです。The position of X is 0 because X is the first type parameter in the type parameter list for GetSomething.

注意

現在の 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 メソッドを使用してその位置を取得し、DeclaringMethod プロパティと DeclaringType プロパティを使用して、それを定義するジェネリックメソッドまたは型定義を確認できます。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.

適用対象

こちらもご覧ください