Type.MakeGenericType(Type[]) Type.MakeGenericType(Type[]) Type.MakeGenericType(Type[]) Type.MakeGenericType(Type[]) Method

Definition

型の配列の要素を現在のジェネリック型定義の型パラメーターで置き換え、結果の構築型を表す Type オブジェクトを返します。 Substitutes the elements of an array of types for the type parameters of the current generic type definition and returns a Type object representing the resulting constructed type.

public:
 virtual Type ^ MakeGenericType(... cli::array <Type ^> ^ typeArguments);
public virtual Type MakeGenericType (params Type[] typeArguments);
abstract member MakeGenericType : Type[] -> Type
override this.MakeGenericType : Type[] -> Type
Public Overridable Function MakeGenericType (ParamArray typeArguments As Type()) As Type

パラメーター

typeArguments
Type[]

現在のジェネリック型の型パラメーターに置き換えられる型の配列。 An array of types to be substituted for the type parameters of the current generic type.

Returns

Type の要素を現在のジェネリック型の型パラメーターで置き換えることによって作られる構築型を表す typeArguments A Type representing the constructed type formed by substituting the elements of typeArguments for the type parameters of the current generic type.

Exceptions

現在の型はジェネリック型の定義を表していません。 The current type does not represent a generic type definition. つまり、IsGenericTypeDefinitionfalse を返します。 That is, IsGenericTypeDefinition returns false.

typeArgumentsnull です。 typeArguments is null. - または - -or- typeArguments のどの要素も null です。 Any element of typeArguments is null.

typeArguments 内の要素数は現在のジェネリック型定義の型パラメーター数と同じではありません。 The number of elements in typeArguments is not the same as the number of type parameters in the current generic type definition. - または - -or- typeArguments のいずれかの要素が、現在のジェネリック型の対応する型パラメーターに指定された制約を満たしていません。 Any element of typeArguments does not satisfy the constraints specified for the corresponding type parameter of the current generic type. - または - -or- typeArguments には、ポインター型 (IsPointertrue を返します)、参照渡し型 (IsByReftrue を返します)、または Void である要素が含まれています。 typeArguments contains an element that is a pointer type (IsPointer returns true), a by-ref type (IsByRef returns true), or Void.

呼び出されたメソッドは基底クラスでサポートされていません。 The invoked method is not supported in the base class. 派生クラスには実装を指定しなければなりません。 Derived classes must provide an implementation.

Examples

次の例では、MakeGenericTypeメソッドのジェネリック型定義から構築された型を作成する、Dictionary<TKey,TValue>型。The following example uses the MakeGenericType method to create a constructed type from the generic type definition for the Dictionary<TKey,TValue> type. 構築された型を表す、Dictionary<TKey,TValue>Test文字列キーを持つオブジェクト。The constructed type represents a Dictionary<TKey,TValue> of Test objects with string keys.

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

namespace Example
{
    public ref class Test
    {
    public:
        static void CreateConstructedType(void)
        {      
            Console::WriteLine("\r\n--- Create a constructed type"
                " from the generic Dictionary`2 type.");
            
            // Create a type object representing 
            // the generic Dictionary`2 type.
    	    Type^ genericType = Type::GetType(
                "System.Collections.Generic.Dictionary`2");
    	    if (genericType != nullptr)
    	    {  
    	        DisplayTypeInfo(genericType);
    	    }
    	    else
    	    {
    	        Console::WriteLine("The type is not found");
    	        return;
    	    }
            
            // Create an array of types to substitute for the type
            // parameters of Dictionary`2. 
            // The key is of type string, and the type to be 
            // contained in the Dictionary`2 is Test.
            array<Type^>^ typeArgs = {String::typeid, Test::typeid};
            Type^ constructedType = 
                genericType->MakeGenericType(typeArgs);
            DisplayTypeInfo(constructedType);
            
            // Compare the type objects obtained above to type objects
            // obtained using typeof() and GetGenericTypeDefinition().
            Console::WriteLine("\r\n--- Compare types obtained by"
                " different methods:");

    	    Type^ definedType = Dictionary<String^, Test^>::typeid;
            Console::WriteLine("\tAre the constructed types "
                "equal? {0}", definedType == constructedType);
            Console::WriteLine("\tAre the generic types equal? {0}", 
                definedType->GetGenericTypeDefinition() == genericType);
        }

    private:
        static void DisplayTypeInfo(Type^ typeToDisplay)
        {   
            Console::WriteLine("\r\n{0}", typeToDisplay);
            Console::WriteLine("\tIs this a generic type definition? "
                "{0}", typeToDisplay->IsGenericTypeDefinition);
            Console::WriteLine("\tIs it a generic type? "
                "{0}", typeToDisplay->IsGenericType);
            
            array<Type^>^ typeArguments = 
                typeToDisplay->GetGenericArguments();
            Console::WriteLine("\tList type arguments ({0}):", 
                typeArguments->Length);
            
            for each (Type^ typeArgument in typeArguments)
            {   
                Console::WriteLine("\t\t{0}", typeArgument);
            }
        }
    };
}

int main(void)
{
    Example::Test::CreateConstructedType();
}

/* This example produces the following output:

--- Create a constructed type from the generic Dictionary`2 type.

System.Collections.Generic.Dictionary`2[KeyType,ValueType]
          Is this a generic type definition? True
          Is it a generic type? True
          List type arguments (2):
                     K
                     V

System.Collections.Generic.Dictionary`2[System.String, Test]
          Is this a generic type definition? False
          Is it a generic type? True
          List type arguments (2):
                     System.String
                     Test

--- Compare types obtained by different methods:
          Are the constructed types equal? True
          Are the generic types equal? True
 */
using System;
using System.Reflection;
using System.Collections.Generic;

public class Test
{
    public static void Main()
    {
        Console.WriteLine("\r\n--- Create a constructed type from the generic Dictionary type.");

        // Create a type object representing the generic Dictionary 
        // type, by omitting the type arguments (but keeping the 
        // comma that separates them, so the compiler can infer the
        // number of type parameters).      
        Type generic = typeof(Dictionary<,>);
        DisplayTypeInfo(generic);

        // Create an array of types to substitute for the type
        // parameters of Dictionary. The key is of type string, and
        // the type to be contained in the Dictionary is Test.
        Type[] typeArgs = { typeof(string), typeof(Test) };

        // Create a Type object representing the constructed generic
        // type.
        Type constructed = generic.MakeGenericType(typeArgs);
        DisplayTypeInfo(constructed);

        // Compare the type objects obtained above to type objects
        // obtained using typeof() and GetGenericTypeDefinition().
        Console.WriteLine("\r\n--- Compare types obtained by different methods:");

        Type t = typeof(Dictionary<String, Test>);
        Console.WriteLine("\tAre the constructed types equal? {0}", t == constructed);
        Console.WriteLine("\tAre the generic types equal? {0}", 
            t.GetGenericTypeDefinition() == generic);
    }

    private static void DisplayTypeInfo(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);

        Type[] typeArguments = t.GetGenericArguments();
        Console.WriteLine("\tList type arguments ({0}):", typeArguments.Length);
        foreach (Type tParam in typeArguments)
        {
            Console.WriteLine("\t\t{0}", tParam);
        }
    }
}

/* This example produces the following output:

--- Create a constructed type from the generic Dictionary type.

System.Collections.Generic.Dictionary`2[TKey,TValue]
        Is this a generic type definition? True
        Is it a generic type? True
        List type arguments (2):
                TKey
                TValue

System.Collections.Generic.Dictionary`2[System.String, Test]
        Is this a generic type definition? False
        Is it a generic type? True
        List type arguments (2):
                System.String
                Test

--- Compare types obtained by different methods:
        Are the constructed types equal? True
        Are the generic types equal? True
 */
Imports System
Imports System.Reflection
Imports System.Collections.Generic
Imports Microsoft.VisualBasic

Public Class Test
    Public Shared Sub Main()
        Console.WriteLine(vbCrLf & "--- Create a constructed type from the generic Dictionary type.")

        ' Create a type object representing the generic Dictionary 
        ' type, by omitting the type arguments (but keeping the 
        ' comma that separates them, so the compiler can infer the
        ' number of type parameters).
        Dim generic As Type = GetType(Dictionary(Of ,))
        DisplayTypeInfo(generic)

        ' Create an array of types to substitute for the type
        ' parameters of Dictionary. The key is of type string, and
        ' the type to be contained in the Dictionary is Test.
        Dim typeArgs() As Type = { GetType(String), GetType(Test) }

        ' Create a Type object representing the constructed generic
        ' type.
        Dim constructed As Type = generic.MakeGenericType(typeArgs)
        DisplayTypeInfo(constructed)

        ' Compare the type objects obtained above to type objects
        ' obtained using GetType() and GetGenericTypeDefinition().
        Console.WriteLine(vbCrLf & "--- Compare types obtained by different methods:")

        Dim t As Type = GetType(Dictionary(Of String, Test))
        Console.WriteLine(vbTab & "Are the constructed types equal? " _
            & (t Is constructed))
        Console.WriteLine(vbTab & "Are the generic types equal? " _ 
            & (t.GetGenericTypeDefinition() Is generic))
    End Sub

    Private Shared Sub DisplayTypeInfo(ByVal t As Type)
        Console.WriteLine(vbCrLf & t.ToString())

        Console.WriteLine(vbTab & "Is this a generic type definition? " _ 
            & t.IsGenericTypeDefinition)

        Console.WriteLine(vbTab & "Is it a generic type? " _ 
            & t.IsGenericType)

        Dim typeArguments() As Type = t.GetGenericArguments()
        Console.WriteLine(vbTab & "List type arguments ({0}):", _
            typeArguments.Length)
        For Each tParam As Type In typeArguments       
            Console.WriteLine(vbTab & vbTab & tParam.ToString())
        Next
    End Sub
End Class

' This example produces the following output:
'
'--- Create a constructed type from the generic Dictionary type.
'
'System.Collections.Generic.Dictionary'2[TKey,TValue]
'        Is this a generic type definition? True
'        Is it a generic type? True
'        List type arguments (2):
'                TKey
'                TValue
'
'System.Collections.Generic.Dictionary`2[System.String,Test]
'        Is this a generic type definition? False
'        Is it a generic type? True
'        List type arguments (2):
'                System.String
'                Test
'
'--- Compare types obtained by different methods:
'        Are the constructed types equal? True
'        Are the generic types equal? True

Remarks

MakeGenericTypeメソッドでは、特定の種類を作成するため、ジェネリック型定義の型パラメーターに代入するコードを記述できます。、Type構築された特定の型を表すオブジェクト。The MakeGenericType method allows you to write code that assigns specific types to the type parameters of a generic type definition, thus creating a Type object that represents a particular constructed type. これを使用することができますType構築された型の実行時のインスタンスを作成するオブジェクト。You can use this Type object to create run-time instances of the constructed type.

型を使用して構築MakeGenericType開くことができる、一部の型引数は、外側のジェネリック メソッドまたは型の型パラメーターを指定できます。Types constructed with MakeGenericType can be open, that is, some of their type arguments can be type parameters of enclosing generic methods or types. 動的アセンブリを生成するときに、このようなオープン構築型を使用する場合があります。You might use such open constructed types when you emit dynamic assemblies. たとえば、クラスBaseDerived次のコード。For example, consider the classes Base and Derived in the following code.

generic<typename T, typename U>
    public ref class Base { };
generic<typename V>
    public ref class Derived : Base<int, V> { };
public class Base<T, U> { }
public class Derived<V> : Base<int, V> { }
Public Class Base(Of T, U)
End Class
Public Class Derived(Of V)
    Inherits Base(Of Integer, V)
End Class

生成するDerived、動的アセンブリではその基本型を構築するために必要です。To generate Derived in a dynamic assembly, it is necessary to construct its base type. これを行うには、呼び出し、MakeGenericTypeメソッドをTypeオブジェクト クラスを表すBase、ジェネリック型引数を使用してInt32、型パラメーターVからDerivedします。To do this, call the MakeGenericType method on a Type object representing the class Base, using the generic type arguments Int32 and the type parameter V from Derived. 型およびジェネリック型パラメーターの両方がによって表されるため、Typeオブジェクトに、両方を含む配列を渡すことができます、MakeGenericTypeメソッド。Because types and generic type parameters are both represented by Type objects, an array containing both can be passed to the MakeGenericType method.

注意

などの構築型Base<int, V>便利な場合に、コードの出力が呼び出すことはできません、MakeGenericTypeこの型のメソッドでジェネリック型定義ではないためです。A constructed type such as Base<int, V> is useful when emitting code, but you cannot call the MakeGenericType method on this type because it is not a generic type definition. 最初に呼び出しをインスタンス化できる構築されたクローズ型を作成する、GetGenericTypeDefinitionを取得するメソッド、Typeをジェネリック型定義を表すオブジェクトを呼び出してMakeGenericType目的の型引数を使用します。To create a closed constructed type that can be instantiated, first call the GetGenericTypeDefinition method to get a Type object representing the generic type definition and then call MakeGenericType with the desired type arguments.

Typeによって返されるオブジェクトMakeGenericTypeと同じ、Type呼び出すことによって取得、GetTypeメソッド結果の構築型、またはGetType構築されたジェネリック同じから作成された型のいずれかのメソッド同じ型の引数を使用して定義を入力します。The Type object returned by MakeGenericType is the same as the Type obtained by calling the GetType method of the resulting constructed type, or the GetType method of any constructed type that was created from the same generic type definition using the same type arguments.

注意

ジェネリック型の配列は自体はジェネリック型です。An array of generic types is not itself a generic type. 呼び出すことはできませんMakeGenericTypeなど、配列で入力C<T>[](Dim ac() As C(Of T) Visual Basic で)。You cannot call MakeGenericType on an array type such as C<T>[] (Dim ac() As C(Of T) in Visual Basic). クローズ ジェネリック型を構築するC<T>[]、呼び出すGetElementTypeジェネリック型定義を取得するC<T>; 呼び出すMakeGenericType上に構築された型; を作成し、最後に呼び出すジェネリック型定義、MakeArrayTypeメソッド配列型の作成に構築された型。To construct a closed generic type from C<T>[], call GetElementType to obtain the generic type definition C<T>; call MakeGenericType on the generic type definition to create the constructed type; and finally call the MakeArrayType method on the constructed type to create the array type. ポインター型の場合も同様とref型 (ByRef Visual Basic で)。The same is true of pointer types and ref types (ByRef in Visual Basic).

ジェネリック リフレクションで使用する用語に関する一定の条件の一覧については、IsGenericType プロパティの解説を参照してください。For a list of the invariant conditions for terms used in generic reflection, see the IsGenericType property remarks.

入れ子にされた型Nested Types

C#、C++、または Visual Basic を使用してジェネリック型が定義されている場合、入れ子にされた型はすべてジェネリックです。If a generic type is defined using C#, C++, or Visual Basic, then its nested types are all generic. これは、入れ子にされた型には、独自の型パラメーターがあるないため、3 つすべての言語は、入れ子にされた型の型パラメーター リストの包含する型の型パラメーターを含む場合でも当てはまります。This is true even if the nested types have no type parameters of their own, because all three languages include the type parameters of enclosing types in the type parameter lists of nested types. 次のクラスを検討してください。Consider the following classes:

generic<typename T> public ref class Outermost
{
public:
    generic<typename U> ref class Inner
    {
    public:
        generic<typename V> ref class Innermost1 {};
        ref class Innermost2 {};
    };
};
public class Outermost<T>
{
    public class Inner<U>
    {
        public class Innermost1<V> {}
        public class Innermost2 {}
    }
}
Public Class Outermost(Of T)
    Public Class Inner(Of U)
        Public Class Innermost1(Of V)
        End Class
        Public Class Innermost2
        End Class
    End Class
End Class

入れ子になったクラスの型パラメーター リストInner2 つの型パラメーターを持つTU、うち 1 つ目は、その外側のクラスの型パラメーター。The type parameter list of the nested class Inner has two type parameters, T and U, the first of which is the type parameter of its enclosing class. 入れ子になったクラスの型パラメーター リスト同様に、 Innermost1 3 つの型パラメーターを持つTU、およびVTU外側のクラスから。Similarly, the type parameter list of the nested class Innermost1 has three type parameters, T, U, and V, with T and U coming from its enclosing classes. 入れ子になったクラスInnermost22 つの型パラメーターを持つTU、その外側のクラスから取得します。The nested class Innermost2 has two type parameters, T and U, which come from its enclosing classes.

それを囲む型のパラメーター リストは、1 つ以上の型パラメーターを持つ、入れ子にされた型の型パラメーター リスト内の順序ですべての型パラメーターが含まれます。If the parameter list of the enclosing type has more than one type parameter, all the type parameters in order are included in the type parameter list of the nested type.

入れ子にされた型のジェネリック型定義からジェネリック型を構築するには、呼び出し、MakeGenericType配列を持つメソッドがすべて包含する型、最も外側のジェネリック型の先頭と末尾の型引数の配列を連結して形成される、独自の型パラメーターを持つ場合は、それ自体には、入れ子にされた型の引数の配列を入力します。To construct a generic type from the generic type definition for a nested type, call the MakeGenericType method with the array formed by concatenating the type argument arrays of all the enclosing types, beginning with the outermost generic type, and ending with the type argument array of the nested type itself, if it has type parameters of its own. インスタンスを作成するInnermost1を呼び出し、 MakeGenericType T、U、および V に割り当てられる次の 3 つの型を含む配列を持つメソッド。インスタンスを作成するInnermost2を呼び出し、 MakeGenericType T と U に割り当てられる 2 つの型を含む配列を持つメソッドTo create an instance of Innermost1, call the MakeGenericType method with an array containing three types, to be assigned to T, U, and V. To create an instance of Innermost2, call the MakeGenericType method with an array containing two types, to be assigned to T and U.

言語は、入れ子にされた型のフィールドを定義する、それを囲む型の型パラメーターを使用できるように、この方法で型を囲む型のパラメーターを伝達します。The languages propagate the type parameters of enclosing types in this fashion so you can use the type parameters of an enclosing type to define fields of nested types. それ以外の場合、型パラメーターは、入れ子にされた型の本文内のスコープにはできません。Otherwise, the type parameters would not be in scope within the bodies of the nested types. 動的アセンブリ内のコードを出力するかを使用して、型を外側の型パラメーターを伝達することがなく、入れ子にされた型を定義することは、 Ilasm.exe (IL アセンブラー)します。It is possible to define nested types without propagating the type parameters of enclosing types, by emitting code in dynamic assemblies or by using the Ilasm.exe (IL Assembler). MSIL アセンブラーの次のコードを検討してください。Consider the following code for the MSIL assembler:

.class public Outer<T> {  
    .class nested public Inner<U> {  
        .class nested public Innermost {  
        }  
    }  
}  

この例では型のフィールドを定義するTまたはUクラスでInnermostスコープにこれらの型パラメーターがないためです。In this example, it is not possible to define a field of type T or U in class Innermost, because those type parameters are not in scope. 次のアセンブラー コードでは、C、Visual Basic、および c# で定義されている場合と同じように動作する入れ子になったクラスを定義します。The following assembler code defines nested classes that behave the way they would if defined in C++, Visual Basic, and C#:

.class public Outer<T> {  
    .class nested public Inner<T, U> {  
        .class nested public Innermost<T, U, V> {  
        }  
    }  
}  

使用することができます、 Ildasm.exe (IL Disassembler)を高度な言語で定義されている入れ子になったクラスを調べて、この名前付けスキームを確認します。You can use the Ildasm.exe (IL Disassembler) to examine nested classes defined in the high-level languages and observe this naming scheme.

Applies to

See Also