Type.IsGenericType プロパティ

定義

名前空間:

System

アセンブリ:

System.Runtime.dll

ソース:

Type.cs

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

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

public virtual bool IsGenericType { get; }

member this.IsGenericType : bool

Public Overridable ReadOnly Property IsGenericType As Boolean

プロパティ値

Boolean

true 現在の型がジェネリック型の場合は 。それ以外の場合は false。

例

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

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

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

open System

type Base<'T, 'U>() = class end

type G<'T>() = class end

type Derived<'V>() =
    inherit Base<string, 'V>()
    
    [<DefaultValue>]
    val mutable public F : G<Derived<'V>>

let displayGenericType (t: Type) caption =
    printfn $"\n{caption}"
    printfn $"    Type: {t}"

    printfn $"\t            IsGenericType: {t.IsGenericType}" 
    printfn $"\t  IsGenericTypeDefinition: {t.IsGenericTypeDefinition}" 
    printfn $"\tContainsGenericParameters: {t.ContainsGenericParameters}"
    printfn $"\t       IsGenericParameter: {t.IsGenericParameter}"

// Get the generic type definition for Derived, and the base
// type for Derived.
let tDerived = typeof<Derived<_>>.GetGenericTypeDefinition()
let tDerivedBase = tDerived.BaseType

// Declare an array of Derived<int>, and get its type.
let d = Array.zeroCreate<Derived<int>> 0
let 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.
let tT = typeof<Base<_,_>>.GetGenericTypeDefinition().GetGenericArguments()[0]
let tF = tDerived.GetField("F").FieldType

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>>"

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

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

注釈

オブジェクトが IsGenericType ジェネリック型を表しているかどうかを Type 判断するには、 プロパティを使用します。 オブジェクトが ContainsGenericParameters 開いている Type 構築型を表すのか、閉じた構築された型を表すのかを判断するには、 プロパティを使用します。

注意

プロパティは IsGenericType 、 false イミディエイト型がジェネリックでない場合に を返します。 たとえば、要素が型 A<int> (A(Of Integer) Visual Basic では) である配列は、それ自体がジェネリック型ではありません。

次の表は、ジェネリック リフレクションで使用される一般的な用語の不変条件をまとめたものです。

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

次のコード例と表は、これらの用語とインバリアントの一部を示しています。 基本型は型引数リストに型パラメーターと型パラメーターの組み合わせを持つ構築された型であるため、クラスは Derived 特に重要です。

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 {};
};

public class Base<T, U> {}

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

    public class Nested {}
}

public class G<T> {}

type Base<'T, 'U>() = class end

type G<'T>() = class end

type Derived<'V>() =
    inherit Base<string, 'V>()
    
    [<DefaultValue>]
    val mutable public F : G<Derived<'V>>

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

次の表は、 クラスBaseDerived、、および で を使用してビルドする例を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の型の場合: IsGenericType は false 配列であるため d です。 IsGenericTypeDefinition が falseです。 ContainsGenericParameters が falseです。
T、 U、および V (表示されるすべての場所)	IsGenericParameter が trueです。 IsGenericType は、 false 型パラメーターをジェネリック型に制限する方法がないためです。 IsGenericTypeDefinition が falseです。 ContainsGenericParametersは、true、U、 V 自体がジェネリック型パラメーターであるためTです。 これは、後でそれらに割り当てられる型引数について何も意味しません。
フィールドの種類 F	IsGenericType が trueです。 IsGenericTypeDefinition は false 、 型が の型パラメーター Gに割り当てられているためです。 これは、 メソッドを呼び出 MakeGenericType したのと同じであることに注意してください。 ContainsGenericParameters は true 、フィールド F の型にオープン構築型の型引数があるためです。 構築された型は、型引数 (つまり) がジェネリック型定義であるため、 Base開いています。 これは、 プロパティの再帰的な性質を IsGenericType 示しています。
入れ子になったクラス Nested	IsGenericType は、 trueクラス自体の Nested ジェネリック型パラメーターがない場合でも、ジェネリック型に入れ子になっているためです。 IsGenericTypeDefinition が trueです。 つまり、 メソッドを MakeGenericType 呼び出し、外側の型 の型パラメーター を Derived指定できます。 ContainsGenericParameters は true 、外側の型 である Derivedがジェネリック型パラメーターを持っているためです。 これは、 プロパティの再帰的な性質を ContainsGenericParameters 示しています。

こちらもご覧ください

• ContainsGenericParameters
• IsGenericTypeDefinition
• リフレクションとジェネリック型
• 方法: リフレクションを使用してジェネリック型をチェックおよびインスタンス化する」を参照してください。