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

정의

형식 배열의 요소를 현재 제네릭 형식 정의의 형식 매개 변수로 대체하며 생성된 형식을 나타내는 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.

반환

Type의 요소를 현재 제네릭 형식의 형식 매개 변수로 대체하여 생성된 형식을 나타내는 typeArguments입니다.A Type representing the constructed type formed by substituting the elements of typeArguments for the type parameters of the current generic type.

예외

현재 형식이 제네릭 형식의 정의를 나타내지 않습니다.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 반환), by-ref 형식(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.

예제

다음 예제에서는 합니다 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

설명

합니다 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

중첩된 된 클래스의 형식 매개 변수 목록 Inner 두 개의 형식 매개 변수가 TU는 첫 번째는 바깥쪽 클래스의 형식 매개 변수입니다.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 세 가지 형식 매개 변수가 T, U, 및 V를 사용 하 여 TU 는 바깥쪽 클래스에서 제공 될 예정입니다.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. 중첩된 클래스 Innermost2 두 개의 형식 매개 변수가 TU는 바깥쪽 클래스에서 제공 되는 합니다.The nested class Innermost2 has two type parameters, T and U, which come from its enclosing classes.

바깥쪽 형식의 매개 변수 목록에 둘 이상의 형식 매개 변수의 경우 순서로 모든 형식 매개 변수는 중첩 형식의 형식 매개 변수 목록에 포함 됩니다.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를 할당할 수는 세 가지 형식이 포함 된 배열 사용 하 여 메서드. 인스턴스를 만드는 Innermost2를 호출 합니다 MakeGenericType 할당할 T 및 u입니다. 두 형식이 포함 된 배열 사용 하 여 메서드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 {  
        }  
    }  
}  

이 예제에서는 수 없는 형식의 필드를 정의 하려면 TU 클래스에서 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 디스어셈블러) 고급 언어에 정의 된 중첩 된 클래스를 검사 하 고이 명명 스키마를 확인할입니다.You can use the Ildasm.exe (IL Disassembler) to examine nested classes defined in the high-level languages and observe this naming scheme.

적용 대상

추가 정보