共用方式為

GenericTypeParameterBuilder.MakeArrayType 方法

  • 參考

定義

命名空間:
System.Reflection.Emit
組件:
System.Reflection.Emit.dll
組件:
mscorlib.dll
組件:
netstandard.dll
套件:
System.Reflection.Emit v4.7.0

傳回陣列的類型，其項目類型是泛型型別參數。

多載

MakeArrayType(Int32)

傳回陣列的類型，其項目類型是以維度數目指定的泛型類型參數。
MakeArrayType()

傳回一維陣列型別，其元素型別為泛型型別參數。

MakeArrayType(Int32)

來源:
GenericTypeParameterBuilder.cs

傳回陣列的類型，其項目類型是以維度數目指定的泛型類型參數。

public:
 override Type ^ MakeArrayType(int rank);
public override Type MakeArrayType (int rank);
override this.MakeArrayType : int -> Type
Public Overrides Function MakeArrayType (rank As Integer) As Type

參數

rank
Int32

陣列的維度數目。

傳回

Type

Type 物件，代表陣列的類型，其項目類型是以維度數目指定的泛型型別參數。

例外狀況

IndexOutOfRangeException

rank 不是有效的維度數目。 例如，其值為小於 1。

範例

下列程式代碼範例會建立動態模組、名為 Sample 的抽象泛型類型，具有一個類型參數， T以及名為的 TestMethod抽象方法。 TestMethod ref會採用 Visual Basic) 類型的參數 (ByRef、型TT別的指標，以及的T陣列。 這個方法會傳回的 T二維陣列。 程式代碼範例會將動態模組儲存至磁碟，因此您可以使用 MSIL 反組譯程式 (Ildasm.exe) 來檢查它。

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

int main()
{
    // Define a dynamic assembly to contain the sample type. The
    // assembly will not be run, but only saved to disk, so
    // AssemblyBuilderAccess.Save is specified.
    //
    AppDomain^ appDomain = AppDomain::CurrentDomain;
    AssemblyName^ assemblyName = gcnew
        AssemblyName("MakeXxxGenericTypeParameterExample");
    AssemblyBuilder^ assemblyBuilder = appDomain->DefineDynamicAssembly
        (assemblyName, AssemblyBuilderAccess::Save);

    // An assembly is made up of executable modules. For a single
    // module assembly, the module name and file name are the
    // same as the assembly name.
    ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule
        (assemblyName->Name, assemblyName->Name + ".dll");

    // Define the sample type.
    TypeBuilder^ typeBuilder = moduleBuilder->DefineType("Sample",
        TypeAttributes::Public | TypeAttributes::Abstract);

    // Make the sample type a generic type, by defining a type
    // parameter T. All type parameters are defined at the same
    // time, by passing an array containing the type parameter
    // names. 
    array<String^>^ typeParamNames = {"T"};
    array<GenericTypeParameterBuilder^>^ typeParams =
        typeBuilder->DefineGenericParameters(typeParamNames);

    // Define a method that takes a ByRef argument of type T, a
    // pointer to type T, and one-dimensional array of type T.
    // The method returns a two-dimensional array of type T.
    //
    // To create this method, you need Type objects that repre-
    // sent the parameter types and the return type. Use the
    // MakeByRefType, MakePointerType, and MakeArrayType methods
    // to create the Type objects, using the generic type para-
    // meter T.
    //
    Type^ byRefType = typeParams[0]->MakeByRefType();
    Type^ pointerType = typeParams[0]->MakePointerType();
    Type^ arrayType = typeParams[0]->MakeArrayType();
    Type^ twoDimArrayType = typeParams[0]->MakeArrayType(2);

    // Create the array of parameter types.
    array<Type^>^ parameterTypes = {byRefType, pointerType, arrayType};

    // Define the abstract Test method. After you have compiled
    // and run this example code, you can use ildasm.exe to open
    // MakeXxxGenericTypeParameterExample.dll, examine the Sample
    // type, and verify the parameter types and return type of
    // the TestMethod method.
    //
    MethodBuilder^ methodBuilder = typeBuilder->DefineMethod("TestMethod",
        MethodAttributes::Abstract | MethodAttributes::Virtual 
        | MethodAttributes::Public, twoDimArrayType, parameterTypes);

    // Create the type and save the assembly. For a single-file 
    // assembly, there is only one module to store the manifest 
    // information in.
    //
    typeBuilder->CreateType();
    assemblyBuilder->Save(assemblyName->Name + ".dll");
};

using System;
using System.Reflection;
using System.Reflection.Emit;
using Microsoft.VisualBasic;

public class Example
{
    public static void Main()
    {
        // Define a dynamic assembly to contain the sample type. The
        // assembly will not be run, but only saved to disk, so
        // AssemblyBuilderAccess.Save is specified.
        //
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName myAsmName = new
            AssemblyName("MakeXxxGenericTypeParameterExample");
        AssemblyBuilder myAssembly = myDomain.DefineDynamicAssembly(
            myAsmName, AssemblyBuilderAccess.Save);

        // An assembly is made up of executable modules. For a single-
        // module assembly, the module name and file name are the same
        // as the assembly name.
        //
        ModuleBuilder myModule = myAssembly.DefineDynamicModule(
            myAsmName.Name, myAsmName.Name + ".dll");

        // Define the sample type.
        TypeBuilder myType = myModule.DefineType("Sample",
            TypeAttributes.Public | TypeAttributes.Abstract);

        // Make the sample type a generic type, by defining a type
        // parameter T. All type parameters are defined at the same
        // time, by passing an array containing the type parameter
        // names.
        string[] typeParamNames = {"T"};
        GenericTypeParameterBuilder[] typeParams =
            myType.DefineGenericParameters(typeParamNames);

        // Define a method that takes a ByRef argument of type T, a
        // pointer to type T, and one-dimensional array of type T. The
        // method returns a two-dimensional array of type T.
        //
        // To create this method, you need Type objects that represent the
        // parameter types and the return type. Use the MakeByRefType,
        // MakePointerType, and MakeArrayType methods to create the Type
        // objects, using the generic type parameter T.
        //
        Type byRefType = typeParams[0].MakeByRefType();
        Type pointerType = typeParams[0].MakePointerType();
        Type arrayType = typeParams[0].MakeArrayType();
        Type twoDimArrayType = typeParams[0].MakeArrayType(2);

        // Create the array of parameter types.
        Type[] parameterTypes = {byRefType, pointerType, arrayType};

        // Define the abstract Test method. After you have compiled
        // and run this example code, you can use ildasm.exe to open
        // MakeXxxGenericTypeParameterExample.dll, examine the Sample
        // type, and verify the parameter types and return type of
        // the TestMethod method.
        //
        MethodBuilder myMethodBuilder = myType.DefineMethod(
            "TestMethod",
            MethodAttributes.Abstract | MethodAttributes.Virtual
            | MethodAttributes.Public,
            twoDimArrayType,
            parameterTypes);

        // Create the type and save the assembly. For a single-file
        // assembly, there is only one module to store the manifest
        // information in.
        //
        myType.CreateType();
        myAssembly.Save(myAsmName.Name + ".dll");
    }
}

Imports System.Reflection
Imports System.Reflection.Emit

Public Class Example
    Public Shared Sub Main()
        ' Define a dynamic assembly to contain the sample type. The
        ' assembly will not be run, but only saved to disk, so
        ' AssemblyBuilderAccess.Save is specified.
        '
        Dim myDomain As AppDomain = AppDomain.CurrentDomain
        Dim myAsmName As New AssemblyName("MakeXxxGenericTypeParameterExample")
        Dim myAssembly As AssemblyBuilder = myDomain.DefineDynamicAssembly( _
            myAsmName, _
            AssemblyBuilderAccess.Save)

        ' An assembly is made up of executable modules. For a single-
        ' module assembly, the module name and file name are the same 
        ' as the assembly name. 
        '
        Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule( _
            myAsmName.Name, _
            myAsmName.Name & ".dll")

        ' Define the sample type.
        Dim myType As TypeBuilder = myModule.DefineType( _
            "Sample", _
            TypeAttributes.Public Or TypeAttributes.Abstract)

        ' Make the sample type a generic type, by defining a type
        ' parameter T. All type parameters are defined at the same
        ' time, by passing an array containing the type parameter
        ' names. 
        Dim typeParamNames() As String = {"T"}
        Dim typeParams() As GenericTypeParameterBuilder = _
            myType.DefineGenericParameters(typeParamNames)

        ' Define a method that takes a ByRef argument of type T, a
        ' pointer to type T, and one-dimensional array of type T. The
        ' method returns a two-dimensional array of type T.
        '
        ' To create this method, you need Type objects that represent the
        ' parameter types and the return type. Use the MakeByRefType, 
        ' MakePointerType, and MakeArrayType methods to create the Type
        ' objects, using the generic type parameter T.
        '
        Dim byRefType As Type = typeParams(0).MakeByRefType
        Dim pointerType As Type = typeParams(0).MakePointerType
        Dim arrayType As Type = typeParams(0).MakeArrayType
        Dim twoDimArrayType As Type = typeParams(0).MakeArrayType(2)

        ' Create the array of parameter types.
        Dim parameterTypes() As Type = _
            {byRefType, pointerType, arrayType}

        ' Define the abstract Test method. After you have compiled
        ' and run this example code, you can use ildasm.exe to open
        ' MakeXxxGenericTypeParameterExample.dll, examine the Sample
        ' type, and verify the parameter types and return type of
        ' the TestMethod method.
        '
        Dim myMethodBuilder As MethodBuilder = myType.DefineMethod( _
            "TestMethod", _
            MethodAttributes.Abstract Or MethodAttributes.Virtual _
                Or MethodAttributes.Public, _
            twoDimArrayType, _
            parameterTypes)

        ' Create the type and save the assembly. For a single-file 
        ' assembly, there is only one module to store the manifest 
        ' information in.
        '
        myType.CreateType()
        myAssembly.Save(myAsmName.Name & ".dll")

    End Sub
End Class

備註

MakeArrayType方法提供一種方式來產生參數清單的數位類型。

另請參閱

適用於

MakeArrayType()

來源:
GenericTypeParameterBuilder.cs

傳回一維陣列型別，其元素型別為泛型型別參數。

public:
 override Type ^ MakeArrayType();
public override Type MakeArrayType ();
override this.MakeArrayType : unit -> Type
Public Overrides Function MakeArrayType () As Type

傳回

Type

Type 物件，表示其元素型別為泛型型別參數的一維陣列型別。

範例

下列程式代碼範例會建立動態模組、名為 Sample 的抽象泛型類型，具有一個類型參數， T以及名為的 TestMethod抽象方法。 TestMethod ref會採用 Visual Basic) 類型的參數 (ByRef、型TT別的指標，以及的T陣列。 這個方法會傳回的 T二維陣列。 程式代碼範例會將動態模組儲存至磁碟，因此您可以使用 MSIL 反組譯程式 (Ildasm.exe) 來檢查它。

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

int main()
{
    // Define a dynamic assembly to contain the sample type. The
    // assembly will not be run, but only saved to disk, so
    // AssemblyBuilderAccess.Save is specified.
    //
    AppDomain^ appDomain = AppDomain::CurrentDomain;
    AssemblyName^ assemblyName = gcnew
        AssemblyName("MakeXxxGenericTypeParameterExample");
    AssemblyBuilder^ assemblyBuilder = appDomain->DefineDynamicAssembly
        (assemblyName, AssemblyBuilderAccess::Save);

    // An assembly is made up of executable modules. For a single
    // module assembly, the module name and file name are the
    // same as the assembly name.
    ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule
        (assemblyName->Name, assemblyName->Name + ".dll");

    // Define the sample type.
    TypeBuilder^ typeBuilder = moduleBuilder->DefineType("Sample",
        TypeAttributes::Public | TypeAttributes::Abstract);

    // Make the sample type a generic type, by defining a type
    // parameter T. All type parameters are defined at the same
    // time, by passing an array containing the type parameter
    // names. 
    array<String^>^ typeParamNames = {"T"};
    array<GenericTypeParameterBuilder^>^ typeParams =
        typeBuilder->DefineGenericParameters(typeParamNames);

    // Define a method that takes a ByRef argument of type T, a
    // pointer to type T, and one-dimensional array of type T.
    // The method returns a two-dimensional array of type T.
    //
    // To create this method, you need Type objects that repre-
    // sent the parameter types and the return type. Use the
    // MakeByRefType, MakePointerType, and MakeArrayType methods
    // to create the Type objects, using the generic type para-
    // meter T.
    //
    Type^ byRefType = typeParams[0]->MakeByRefType();
    Type^ pointerType = typeParams[0]->MakePointerType();
    Type^ arrayType = typeParams[0]->MakeArrayType();
    Type^ twoDimArrayType = typeParams[0]->MakeArrayType(2);

    // Create the array of parameter types.
    array<Type^>^ parameterTypes = {byRefType, pointerType, arrayType};

    // Define the abstract Test method. After you have compiled
    // and run this example code, you can use ildasm.exe to open
    // MakeXxxGenericTypeParameterExample.dll, examine the Sample
    // type, and verify the parameter types and return type of
    // the TestMethod method.
    //
    MethodBuilder^ methodBuilder = typeBuilder->DefineMethod("TestMethod",
        MethodAttributes::Abstract | MethodAttributes::Virtual 
        | MethodAttributes::Public, twoDimArrayType, parameterTypes);

    // Create the type and save the assembly. For a single-file 
    // assembly, there is only one module to store the manifest 
    // information in.
    //
    typeBuilder->CreateType();
    assemblyBuilder->Save(assemblyName->Name + ".dll");
};

using System;
using System.Reflection;
using System.Reflection.Emit;
using Microsoft.VisualBasic;

public class Example
{
    public static void Main()
    {
        // Define a dynamic assembly to contain the sample type. The
        // assembly will not be run, but only saved to disk, so
        // AssemblyBuilderAccess.Save is specified.
        //
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName myAsmName = new
            AssemblyName("MakeXxxGenericTypeParameterExample");
        AssemblyBuilder myAssembly = myDomain.DefineDynamicAssembly(
            myAsmName, AssemblyBuilderAccess.Save);

        // An assembly is made up of executable modules. For a single-
        // module assembly, the module name and file name are the same
        // as the assembly name.
        //
        ModuleBuilder myModule = myAssembly.DefineDynamicModule(
            myAsmName.Name, myAsmName.Name + ".dll");

        // Define the sample type.
        TypeBuilder myType = myModule.DefineType("Sample",
            TypeAttributes.Public | TypeAttributes.Abstract);

        // Make the sample type a generic type, by defining a type
        // parameter T. All type parameters are defined at the same
        // time, by passing an array containing the type parameter
        // names.
        string[] typeParamNames = {"T"};
        GenericTypeParameterBuilder[] typeParams =
            myType.DefineGenericParameters(typeParamNames);

        // Define a method that takes a ByRef argument of type T, a
        // pointer to type T, and one-dimensional array of type T. The
        // method returns a two-dimensional array of type T.
        //
        // To create this method, you need Type objects that represent the
        // parameter types and the return type. Use the MakeByRefType,
        // MakePointerType, and MakeArrayType methods to create the Type
        // objects, using the generic type parameter T.
        //
        Type byRefType = typeParams[0].MakeByRefType();
        Type pointerType = typeParams[0].MakePointerType();
        Type arrayType = typeParams[0].MakeArrayType();
        Type twoDimArrayType = typeParams[0].MakeArrayType(2);

        // Create the array of parameter types.
        Type[] parameterTypes = {byRefType, pointerType, arrayType};

        // Define the abstract Test method. After you have compiled
        // and run this example code, you can use ildasm.exe to open
        // MakeXxxGenericTypeParameterExample.dll, examine the Sample
        // type, and verify the parameter types and return type of
        // the TestMethod method.
        //
        MethodBuilder myMethodBuilder = myType.DefineMethod(
            "TestMethod",
            MethodAttributes.Abstract | MethodAttributes.Virtual
            | MethodAttributes.Public,
            twoDimArrayType,
            parameterTypes);

        // Create the type and save the assembly. For a single-file
        // assembly, there is only one module to store the manifest
        // information in.
        //
        myType.CreateType();
        myAssembly.Save(myAsmName.Name + ".dll");
    }
}

Imports System.Reflection
Imports System.Reflection.Emit

Public Class Example
    Public Shared Sub Main()
        ' Define a dynamic assembly to contain the sample type. The
        ' assembly will not be run, but only saved to disk, so
        ' AssemblyBuilderAccess.Save is specified.
        '
        Dim myDomain As AppDomain = AppDomain.CurrentDomain
        Dim myAsmName As New AssemblyName("MakeXxxGenericTypeParameterExample")
        Dim myAssembly As AssemblyBuilder = myDomain.DefineDynamicAssembly( _
            myAsmName, _
            AssemblyBuilderAccess.Save)

        ' An assembly is made up of executable modules. For a single-
        ' module assembly, the module name and file name are the same 
        ' as the assembly name. 
        '
        Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule( _
            myAsmName.Name, _
            myAsmName.Name & ".dll")

        ' Define the sample type.
        Dim myType As TypeBuilder = myModule.DefineType( _
            "Sample", _
            TypeAttributes.Public Or TypeAttributes.Abstract)

        ' Make the sample type a generic type, by defining a type
        ' parameter T. All type parameters are defined at the same
        ' time, by passing an array containing the type parameter
        ' names. 
        Dim typeParamNames() As String = {"T"}
        Dim typeParams() As GenericTypeParameterBuilder = _
            myType.DefineGenericParameters(typeParamNames)

        ' Define a method that takes a ByRef argument of type T, a
        ' pointer to type T, and one-dimensional array of type T. The
        ' method returns a two-dimensional array of type T.
        '
        ' To create this method, you need Type objects that represent the
        ' parameter types and the return type. Use the MakeByRefType, 
        ' MakePointerType, and MakeArrayType methods to create the Type
        ' objects, using the generic type parameter T.
        '
        Dim byRefType As Type = typeParams(0).MakeByRefType
        Dim pointerType As Type = typeParams(0).MakePointerType
        Dim arrayType As Type = typeParams(0).MakeArrayType
        Dim twoDimArrayType As Type = typeParams(0).MakeArrayType(2)

        ' Create the array of parameter types.
        Dim parameterTypes() As Type = _
            {byRefType, pointerType, arrayType}

        ' Define the abstract Test method. After you have compiled
        ' and run this example code, you can use ildasm.exe to open
        ' MakeXxxGenericTypeParameterExample.dll, examine the Sample
        ' type, and verify the parameter types and return type of
        ' the TestMethod method.
        '
        Dim myMethodBuilder As MethodBuilder = myType.DefineMethod( _
            "TestMethod", _
            MethodAttributes.Abstract Or MethodAttributes.Virtual _
                Or MethodAttributes.Public, _
            twoDimArrayType, _
            parameterTypes)

        ' Create the type and save the assembly. For a single-file 
        ' assembly, there is only one module to store the manifest 
        ' information in.
        '
        myType.CreateType()
        myAssembly.Save(myAsmName.Name & ".dll")

    End Sub
End Class

備註

MakeArrayType方法提供一種方式來產生參數清單的數位類型。

另請參閱

適用於