Type.GenericParameterPosition プロパティとは何？わかりやすく解説 Weblio辞書

すべての辞書から再検索する

.NET Framework クラスライブラリリファレンス

索引トップ用語の索引ランキング

Type.GenericParameterPosition プロパティ

メモ : このプロパティは、.NET Framework version 2.0 で新しく追加されたものです。

Type オブジェクトがジェネリック型またはジェネリックメソッドの型パラメータを表す場合に、パラメータを宣言したジェネリック型またはジェネリックメソッドの型パラメータリスト内の型パラメータの位置を取得します。

名前空間: System
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

Public Overridable ReadOnly
 Property GenericParameterPosition As Integer

Visual Basic (使用法)

Dim instance As Type
Dim value As Integer

value = instance.GenericParameterPosition

public virtual int GenericParameterPosition
 { get; }

C++

public:
virtual property int GenericParameterPosition {
    int get ();
}

/** @property */
public int get_GenericParameterPosition ()

JScript

public function get GenericParameterPosition
 () : int

プロパティ値
パラメータを宣言するジェネリック型またはジェネリックメソッドの型パラメータリスト内の型パラメータの位置。位置の番号は 0 で始まります。

例外

例外の種類	条件
InvalidOperationException	現在の型は型パラメータを表しません。つまり、IsGenericParameter は false を返します。

解説

GenericParameterPosition プロパティは、型が最初に定義されたジェネリック型定義またはジェネリックメソッド定義のパラメータリスト内での型パラメータの位置を返します。DeclaringType プロパティおよび DeclaringMethod プロパティはジェネリック型定義またはジェネリックメソッド定義を識別します。

DeclaringMethod プロパティが MethodInfo を返す場合、その MethodInfo はジェネリックメソッド定義を表し、現在の Type オブジェクトはそのジェネリックメソッド定義の型パラメータを表します。
DeclaringMethod プロパティが null 参照 (Visual Basic では Nothing) を返す場合、DeclaringType プロパティは常にジェネリック型定義を表す Type オブジェクトを返します。Type オブジェクトは、そのジェネリック型定義の型パラメータを表します。

GenericParameterPosition プロパティの値の正しいコンテキストを提供するには、型パラメータが属するジェネリック型またはジェネリックメソッドを識別する必要があります。たとえば、次のコード例でジェネリックメソッド GetSomething の戻り値について考えてみましょう。

Visual Basic

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

public class B<T, U> { }
public class A<V>
{
    public B<V, X> GetSomething<X>()
    {
        return new B<V, X>();
    }
}

C++

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 Base<V, X>();
    }
};

GetSomething によって返される型は、A および GetSomething そのものに提供される型引数によって決まります。GetSomething の MethodInfo を取得してから、戻り値の型を取得できます。戻り値の型の型パラメータを調べると、GenericParameterPosition は両方に 0 を返します。V はクラス A の型パラメータリスト内の最初の型パラメータなので、V の位置は 0 です。X は GetSomething の型パラメータリスト内の最初の型パラメータなので、X の位置は 0 です。

メモ
GenericParameterPosition プロパティを呼び出したときに、現在の Type が型パラメータを表していない場合は例外が発生します。オープン構築型の型引数を調べる場合は、IsGenericParameter プロパティを使用して、どちらが型パラメータでどちらが型であるかを識別できます。IsGenericParameter プロパティによって型パラメータに true が返されたら、GenericParameterPosition メソッドで位置を取得し、DeclaringMethod プロパティおよび DeclaringType プロパティを使ってジェネリックメソッド定義またはジェネリック型定義を決定します。

メモ

GenericParameterPosition プロパティを呼び出したときに、現在の Type が型パラメータを表していない場合は例外が発生します。オープン構築型の型引数を調べる場合は、IsGenericParameter プロパティを使用して、どちらが型パラメータでどちらが型であるかを識別できます。IsGenericParameter プロパティによって型パラメータに true が返されたら、GenericParameterPosition メソッドで位置を取得し、DeclaringMethod プロパティおよび DeclaringType プロパティを使ってジェネリックメソッド定義またはジェネリック型定義を決定します。

使用例

2 つの型パラメータを指定したジェネリッククラス、および最初のクラスから派生する 2 番目のジェネリッククラスを定義する例を次に示します。派生クラスの基本クラスには 2 つの型引数があります。最初の型引数は Int32 で、2 番目の型引数は派生型の型パラメータです。この例では、GenericParameterPosition プロパティによって報告された位置を含む、ジェネリッククラスの情報が示されています。

Visual Basic

Imports System
Imports System.Reflection
Imports System.Collections.Generic
Imports Microsoft.VisualBasic

' 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 'Main
    
    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 'DisplayGenericTypeInfo
End Class 'Test

' 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)
'

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)
 */

C++

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)
 */

プラットフォーム

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報

.NET Framework
サポート対象 : 2.0

参照

関連項目
Type クラス
Type メンバ
System 名前空間
MakeGenericType
Type.ContainsGenericParameters プロパティ
IsGenericParameter
その他の技術情報
リフレクションとジェネリック型
方法 : リフレクションを使用してジェネリック型をチェックおよびインスタンス化する

このページでは「.NET Framework クラスライブラリリファレンス」からType.GenericParameterPosition プロパティを検索した結果を表示しています。
Weblioに収録されているすべての辞書からType.GenericParameterPosition プロパティを検索する場合は、下記のリンクをクリックしてください。

全ての辞書からType.GenericParameterPosition プロパティを検索

>> 「Type.GenericParameterPosition プロパティ」を含む用語の索引
Type.GenericParameterPosition プロパティのページへのリンク

Type.GenericParameterPosition プロパティとは？わかりやすく解説

Type.GenericParameterPosition プロパティ

「Type.GenericParameterPosition プロパティ」の関連用語


	© 2025 Microsoft.All rights reserved.

Type.GenericParameterPosition プロパティとは？ わかりやすく解説

Type.GenericParameterPosition プロパティ

急上昇のことば

「Type.GenericParameterPosition プロパティ」の関連用語

Type.GenericParameterPosition プロパティとは？わかりやすく解説