GenericTypeParameterBuilder.MakeArrayType Método
Definição
Retorna o tipo de uma matriz cujo tipo de elemento é o parâmetro de tipo genérico.Returns the type of an array whose element type is the generic type parameter.
Sobrecargas
| MakeArrayType() |
Retorna o tipo de uma matriz unidimensional cujo tipo de elemento é o parâmetro de tipo genérico.Returns the type of a one-dimensional array whose element type is the generic type parameter. |
| MakeArrayType(Int32) |
Retorna o tipo de uma matriz cujo tipo de elemento é o parâmetro de tipo genérico, com o número de dimensões especificado.Returns the type of an array whose element type is the generic type parameter, with the specified number of dimensions. |
MakeArrayType()
Retorna o tipo de uma matriz unidimensional cujo tipo de elemento é o parâmetro de tipo genérico.Returns the type of a one-dimensional array whose element type is the generic type parameter.
public:
override Type ^ MakeArrayType();
public override Type MakeArrayType ();
override this.MakeArrayType : unit -> Type
Public Overrides Function MakeArrayType () As Type
Retornos
Um objeto Type que representa o tipo de uma matriz unidimensional cujo tipo de elemento é o parâmetro de tipo genérico.A Type object that represents the type of a one-dimensional array whose element type is the generic type parameter.
Exemplos
O exemplo de código a seguir cria um módulo dinâmico, um tipo genérico abstrato chamado Sample com um parâmetro de tipo, T e um método abstrato chamado TestMethod .The following code example creates a dynamic module, an abstract generic type named Sample with one type parameter, T, and an abstract method named TestMethod. TestMethod usa um ref parâmetro ( ByRef em Visual Basic) do tipo T , um ponteiro para o tipo T e uma matriz de T .TestMethod takes a ref parameter (ByRef in Visual Basic) of type T, a pointer to type T, and an array of T. Esse método retorna uma matriz bidimensional de T .This method returns a two-dimensional array of T. O exemplo de código salva o módulo dinâmico em disco, para que você possa examiná-lo usando o desmontador MSIL (Ildasm.exe).The code example saves the dynamic module to disk, so you can examine it using the MSIL Disassembler (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
Comentários
O MakeArrayType método fornece uma maneira de gerar tipos de matriz para listas de parâmetros.The MakeArrayType method provides a way to generate array types for parameter lists.
Confira também
Aplica-se a
MakeArrayType(Int32)
Retorna o tipo de uma matriz cujo tipo de elemento é o parâmetro de tipo genérico, com o número de dimensões especificado.Returns the type of an array whose element type is the generic type parameter, with the specified number of dimensions.
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
Parâmetros
- rank
- Int32
O número de dimensões da matriz.The number of dimensions for the array.
Retornos
Um objeto Type que representa o tipo de uma matriz cujo tipo de elemento é o parâmetro de tipo genérico, com o número de dimensões especificado.A Type object that represents the type of an array whose element type is the generic type parameter, with the specified number of dimensions.
Exceções
rank não é um número de dimensões válido.rank is not a valid number of dimensions. Por exemplo, seu valor é menor que 1.For example, its value is less than 1.
Exemplos
O exemplo de código a seguir cria um módulo dinâmico, um tipo genérico abstrato chamado Sample com um parâmetro de tipo, T e um método abstrato chamado TestMethod .The following code example creates a dynamic module, an abstract generic type named Sample with one type parameter, T, and an abstract method named TestMethod. TestMethod usa um ref parâmetro ( ByRef em Visual Basic) do tipo T , um ponteiro para o tipo T e uma matriz de T .TestMethod takes a ref parameter (ByRef in Visual Basic) of type T, a pointer to type T, and an array of T. Esse método retorna uma matriz bidimensional de T .This method returns a two-dimensional array of T. O exemplo de código salva o módulo dinâmico em disco, para que você possa examiná-lo usando o desmontador MSIL (Ildasm.exe).The code example saves the dynamic module to disk, so you can examine it using the MSIL Disassembler (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
Comentários
O MakeArrayType método fornece uma maneira de gerar tipos de matriz para listas de parâmetros.The MakeArrayType method provides a way to generate array types for parameter lists.