Type.IsGenericType プロパティ

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

Type.IsGenericType プロパティ

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

現在の型がジェネリック型かどうかを示す値を取得します。

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

Visual Basic (宣言)

Public Overridable ReadOnly
 Property IsGenericType As Boolean

Visual Basic (使用法)

Dim instance As Type
Dim value As Boolean

value = instance.IsGenericType

C#

public virtual bool IsGenericType { get;
 }

C++

public:
virtual property bool IsGenericType {
    bool get ();
}

J#

/** @property */
public boolean get_IsGenericType ()

JScript

public function get IsGenericType
 () : boolean

プロパティ値
現在の型がジェネリック型の場合は true。それ以外の場合は false。

解説

IsGenericType プロパティを使用して、Type オブジェクトがジェネリック型を表すかどうかを決定します。ContainsGenericParameters プロパティを使用して、Type オブジェクトがオープン構築型を表すか、またはクローズ構築型を表すかを決定します。

メモ
直接の型がジェネリックでない場合、IsGenericType プロパティは false を返します。たとえば、配列の要素の型が A<int> (Visual Basic の場合は A(Of Integer)) である場合、配列そのものはジェネリック型ではありません。

ジェネリック リフレクションで使われる一般的な用語に関する一定の条件を次の表に示します。

用語	一定の条件
ジェネリック型定義	IsGenericTypeDefinition プロパティが true です。 ジェネリック型を定義します。構築型は、型引数の配列を指定し、ジェネリック型定義を表す Type オブジェクトで MakeGenericType メソッドを呼び出すことにより作成されます。 MakeGenericType は、ジェネリック型定義でのみ呼び出すことができます。 すべてのジェネリック型定義はジェネリック型ですが (IsGenericType プロパティは true)、ジェネリック型がすべてジェネリック型定義というわけではありません。
ジェネリック型	IsGenericType プロパティが true です。 ジェネリック型には、ジェネリック型定義、オープン構築型、またはクローズ構築型があります。 配列型の要素型がジェネリックである場合に、配列型そのものがジェネリック型でないことに注意してください。ジェネリック型へのポインタを表す Type オブジェクトも同様です。
オープン構築型	ContainsGenericParameters プロパティが true です。 例は、未割り当ての型パラメータを持つジェネリック型、ジェネリック型定義またはオープン構築型に入れ子にされた型、あるいは ContainsGenericParameters プロパティが true である型引数を持つジェネリック型です。 オープン構築型のインスタンスは作成できません。 オープン構築型がすべてジェネリック型ではないことに注意してください。たとえば、要素型がジェネリック型定義である配列はジェネリック型ではなく、オープン構築型へのポインタはジェネリック型ではありません。
クローズ構築型	ContainsGenericParameters プロパティが false です。 再帰的に調べた場合に、この型には未割り当てのジェネリック パラメータはありません。
ジェネリック型パラメータ	IsGenericParameter プロパティが true です。 ジェネリック型定義で、後から割り当てられる型のプレースホルダです。
ジェネリック型引数	ジェネリック型パラメータなど任意の型にすることができます。 型引数は、構築ジェネリック型を作成するときに、MakeGenericType メソッドに渡される Type オブジェクトの配列として指定されます。結果の型のインスタンスが作成される場合、ContainsGenericParameters プロパティはすべての型引数に対して false にする必要があります。

次のコード例および表には、これらの用語およびインバリアントが示されています。Derived クラスの基本クラスは構築型なので、特に興味深いクラスです。型引数リスト内にさまざまな型および型パラメータが混在しています。

Visual Basic

Public Class Base(Of T,
 U)
End Class
Public Class Derived(Of
 V) 
    Inherits Base(Of String,
 V)
    Public F As G(Of Derived(Of
 V))
    Public Class Nested
    End Class
End Class
Public Class G(Of T)
End Class 

C#

public class Base<T,U> {}
public class Derived<V> : Base<String,V>
 
{
    public G<Derived<V>> F;
    public class Nested {}
}
public class G<T> {}

C++

generic <typename T> public ref class
 G {};
generic <typename T, typename U> public ref class
 Base {};
generic <typename V> public ref class
 Derived : Base<String^,V> {
public:
    G<Derived<V>^>^ F;
    ref class Nested {};
};

Base、Derived、および G の各クラスを使用して構築する例を次の表に示します。C++ および C# のコードが同じである場合は、1 つのエントリのみが示されています。

例	一定の条件
Derived(Of V) Derived<V>	この型の場合 IsGenericType が true です。 IsGenericTypeDefinition が true です。 ContainsGenericParameters が true です。
Base(Of String, V) Base<String,V> Base<String^,V>	この型の場合 IsGenericType が true です。 IsGenericTypeDefinition が false です。 ContainsGenericParameters が true です。
Dim d() As Derived(Of Integer) Derived<int>[] d; array<Derived<int>^>^ d;	変数 d の型の場合 d は配列なので IsGenericType は false です。 IsGenericTypeDefinition が false です。 ContainsGenericParameters が false です。
T、U、および V (出現するあらゆる箇所で)	IsGenericParameter が true です。 型パラメータをジェネリック型に制約する方法がないので、IsGenericType は false です。 IsGenericTypeDefinition が false です。 ContainsGenericParameters が false です。
フィールド F の型	IsGenericType が true です。 型は G の型パラメータに割り当てられているので、IsGenericTypeDefinition は false です。これは MakeGenericType メソッドを呼び出した場合と同じであることに注意してください。 フィールド F の型が持っている型引数はオープン構築型なので、ContainsGenericParameters は true です。構築型の型引数 (Base) はジェネリック型定義なので、構築型は開いた型です。これは、IsGenericType プロパティの再帰的な性質を示しています。
入れ子になっているクラス Nested	Nested クラスに固有のジェネリック型パラメータがなくても、ジェネリック型の入れ子になっているので、IsGenericType は true です。 IsGenericTypeDefinition が true です。つまり、MakeGenericType メソッドを呼び出して、包含する型の型パラメータを提供できます (Derived)。 包含する型 Derived がジェネリック型パラメータを持っているので、ContainsGenericParameters は true です。これは、ContainsGenericParameters プロパティの再帰的な性質を示しています。

使用例

次のコード例では、「解説」で説明している型に対して IsGenericType、IsGenericTypeDefinition、IsGenericParameter、および ContainsGenericParameters の各プロパティの値を示します。プロパティ値の詳細については、「解説」の表を参照してください。

Visual Basic

Imports System
Imports System.Reflection

' 
Public Class Base(Of T,
 U)
End Class

Public Class Derived(Of
 V) 
    Inherits Base(Of String,
 V)

    Public F As G(Of Derived(Of
 V))

    Public Class Nested
    End Class
End Class

Public Class G(Of T)
End Class 

Module Example

    Sub Main

        ' Get the generic type definition for Derived, and the base
        ' type for Derived.
        '
        Dim tDerived As Type = GetType(Derived(Of
 ))
        Dim tDerivedBase As Type = tDerived.BaseType

        ' Declare an array of Derived(Of Integer), and get its type.
        '
        Dim d(0) As Derived(Of
 Integer)
        Dim tDerivedArray As Type = d.GetType()

        ' Get a generic type parameter, the type of a field, and a
        ' type that is nested in Derived. Notice that in order to
        ' get the nested type it is necessary to either (1) specify
        ' the generic type definition Derived(Of ), as shown here,
        ' or (2) specify a type parameter for Derived.
        '
        Dim tT As Type = GetType(Base(Of
 ,)).GetGenericArguments()(0)
        Dim tF As Type = tDerived.GetField("F").FieldType
        Dim tNested As Type = GetType(Derived(Of
 ).Nested)

        DisplayGenericType(tDerived, "Derived(Of V)")
        DisplayGenericType(tDerivedBase, "Base type of Derived(Of
 V)")
        DisplayGenericType(tDerivedArray, "Array of Derived(Of
 Integer)")
        DisplayGenericType(tT, "Type parameter T from Base(Of
 T)")
        DisplayGenericType(tF, "Field type, G(Of Derived(Of V))")
        DisplayGenericType(tNested, "Nested type in Derived(Of
 V)")

    End Sub

    Sub DisplayGenericType(ByVal t As
 Type, ByVal caption As String)

        Console.WriteLine(vbLf & caption)
        Console.WriteLine("    Type: {0}", t)

        Console.WriteLine(vbTab & "            IsGenericType:
 {0}", _
            t.IsGenericType)
        Console.WriteLine(vbTab & "  IsGenericTypeDefinition:
 {0}", _
            t.IsGenericTypeDefinition)
        Console.WriteLine(vbTab & "ContainsGenericParameters:
 {0}", _
            t.ContainsGenericParameters)
        Console.WriteLine(vbTab & "       IsGenericParameter:
 {0}", _
            t.IsGenericParameter)

    End Sub

End Module

' This code example produces the following output:
'
'Derived(Of V)
'    Type: Derived`1[V]
'                    IsGenericType: True
'          IsGenericTypeDefinition: True
'        ContainsGenericParameters: True
'               IsGenericParameter: False
'
'Base type of Derived(Of V)
'    Type: Base`2[System.String,V]
'                    IsGenericType: True
'          IsGenericTypeDefinition: False
'        ContainsGenericParameters: True
'               IsGenericParameter: False
'
'Array of Derived(Of Integer)
'    Type: Derived`1[System.Int32][]
'                    IsGenericType: False
'          IsGenericTypeDefinition: False
'        ContainsGenericParameters: False
'               IsGenericParameter: False
'
'Type parameter T from Base(Of T)
'    Type: T
'                    IsGenericType: False
'          IsGenericTypeDefinition: False
'        ContainsGenericParameters: True
'               IsGenericParameter: True
'
'Field type, G(Of Derived(Of V))
'    Type: G`1[Derived`1[V]]
'                    IsGenericType: True
'          IsGenericTypeDefinition: False
'        ContainsGenericParameters: True
'               IsGenericParameter: False
'
'Nested type in Derived(Of V)
'    Type: Derived`1+Nested[V]
'                    IsGenericType: True
'          IsGenericTypeDefinition: True
'        ContainsGenericParameters: True
'               IsGenericParameter: False

C#

using System;
using System.Reflection;

public class Base<T, U> {}

public class Derived<V> : Base<string,
 V>
{
    public G<Derived <V>> F;

    public class Nested {}
}

public class G<T> {}

class Example
{
    public static void Main()
    {
        // Get the generic type definition for Derived, and the base
        // type for Derived.
        //
        Type tDerived = typeof(Derived<>);
        Type tDerivedBase = tDerived.BaseType;

        // Declare an array of Derived<int>, and get its type.
        //
        Derived<int>[] d = new Derived<int>[0];
        Type tDerivedArray = d.GetType();

        // Get a generic type parameter, the type of a field, and a
        // type that is nested in Derived. Notice that in order to
        // get the nested type it is necessary to either (1) specify
        // the generic type definition Derived<>, as shown here
,
        // or (2) specify a type parameter for Derived.
        //
        Type tT = typeof(Base<,>).GetGenericArguments()[0];
        Type tF = tDerived.GetField("F").FieldType;
        Type tNested = typeof(Derived<>.Nested);

        DisplayGenericType(tDerived, "Derived<V>");
        DisplayGenericType(tDerivedBase, "Base type of Derived<V>");
        DisplayGenericType(tDerivedArray, "Array of Derived<int>");
        DisplayGenericType(tT, "Type parameter T from Base<T>");
        DisplayGenericType(tF, "Field type, G<Derived<V>>");
        DisplayGenericType(tNested, "Nested type in Derived<V>");
    }

    public static void DisplayGenericType(Type
 t, string caption)
    {
        Console.WriteLine("\n{0}", caption);
        Console.WriteLine("    Type: {0}", t);

        Console.WriteLine("\t            IsGenericType: {0}", 
            t.IsGenericType);
        Console.WriteLine("\t  IsGenericTypeDefinition: {0}", 
            t.IsGenericTypeDefinition);
        Console.WriteLine("\tContainsGenericParameters: {0}", 
            t.ContainsGenericParameters);
        Console.WriteLine("\t       IsGenericParameter: {0}", 
            t.IsGenericParameter);
    }
}

/* This code example produces the following output:

Derived<V>
    Type: Derived`1[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False

Base type of Derived<V>
    Type: Base`2[System.String,V]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Array of Derived<int>
    Type: Derived`1[System.Int32][]
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: False
               IsGenericParameter: False

Type parameter T from Base<T>
    Type: T
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: True

Field type, G<Derived<V>>
    Type: G`1[Derived`1[V]]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Nested type in Derived<V>
    Type: Derived`1+Nested[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False
 */

C++

using namespace System;
using namespace System::Reflection;

generic<typename T, typename U> public ref class
 Base {};

generic<typename T> public ref class
 G {};

generic<typename V> public ref class
 Derived : Base<String^, V>
{
public: 
    G<Derived<V>^>^ F;

    ref class Nested {};
};

void DisplayGenericType(Type^ t, String^ caption)
{
    Console::WriteLine("\n{0}", caption);
    Console::WriteLine("    Type: {0}", t);

    Console::WriteLine("\t            IsGenericType: {0}", 
        t->IsGenericType);
    Console::WriteLine("\t  IsGenericTypeDefinition: {0}", 
        t->IsGenericTypeDefinition);
    Console::WriteLine("\tContainsGenericParameters: {0}", 
        t->ContainsGenericParameters);
    Console::WriteLine("\t       IsGenericParameter: {0}", 
        t->IsGenericParameter);
}

void main()
{
    // Get the generic type definition for Derived, and the base
    // type for Derived.
    //
    Type^ tDerived = Derived::typeid;
    Type^ tDerivedBase = tDerived->BaseType;

    // Declare an array of Derived<int>, and get its type.
    //
    array<Derived<int>^>^ d = gcnew array<Derived<int>^>(0);
    Type^ tDerivedArray = d->GetType();

    // Get a generic type parameter, the type of a field, and a
    // type that is nested in Derived. Notice that in order to
    // get the nested type it is necessary to either (1) specify
    // the generic type definition Derived::typeid, as shown here,
    // or (2) specify a type parameter for Derived.
    //
    Type^ tT = Base::typeid->GetGenericArguments()[0];
    Type^ tF = tDerived->GetField("F")->FieldType;
    Type^ tNested = Derived::Nested::typeid;

    DisplayGenericType(tDerived, "generic<V> Derived");
    DisplayGenericType(tDerivedBase, "Base type of generic<V> Derived");
    DisplayGenericType(tDerivedArray, "Array of Derived<int>");
    DisplayGenericType(tT, "Type parameter T from generic<T> Base");
    DisplayGenericType(tF, "Field type, G<Derived<V>^>^");
    DisplayGenericType(tNested, "Nested type in generic<V>
 Derived");
}

/* This code example produces the following output:

generic<V> Derived
    Type: Derived`1[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False

Base type of generic<V> Derived
    Type: Base`2[System.String,V]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Array of Derived<int>
    Type: Derived`1[System.Int32][]
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: False
               IsGenericParameter: False

Type parameter T from generic<T> Base
    Type: T
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: True

Field type, G<Derived<V>^>^
    Type: G`1[Derived`1[V]]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Nested type in generic<V> Derived
    Type: Derived`1+Nested[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False
 */

プラットフォーム

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
.NET Compact Framework
サポート対象 : 2.0

参照

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