GenericTypeParameterBuilder.MakeArrayType Method
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Returns the type of an array whose element type is the generic type parameter.
Overloads
MakeArrayType(Int32) |
Returns the type of an array whose element type is the generic type parameter, with the specified number of dimensions. |
MakeArrayType() |
Returns the type of a one-dimensional array whose element type is the generic type parameter. |
MakeArrayType(Int32)
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
Parameters
- rank
- Int32
The number of dimensions for the array.
Returns
A Type object that represents the type of an array whose element type is the generic type parameter, with the specified number of dimensions.
Exceptions
rank
is not a valid number of dimensions. For example, its value is less than 1.
Examples
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
takes a ref
parameter (ByRef
in Visual Basic) of type T
, a pointer to type T
, and an array of T
. This method returns a two-dimensional array of T
. 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
Remarks
The MakeArrayType method provides a way to generate array types for parameter lists.
See also
Applies to
MakeArrayType()
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
Returns
A Type object that represents the type of a one-dimensional array whose element type is the generic type parameter.
Examples
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
takes a ref
parameter (ByRef
in Visual Basic) of type T
, a pointer to type T
, and an array of T
. This method returns a two-dimensional array of T
. 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
Remarks
The MakeArrayType method provides a way to generate array types for parameter lists.
See also
Applies to
Feedback
https://aka.ms/ContentUserFeedback.
Binnenkort: Gedurende 2024 worden GitHub Issues uitgefaseerd als het feedbackmechanisme voor inhoud. Dit wordt vervangen door een nieuw feedbacksysteem. Ga voor meer informatie naar:Feedback verzenden en bekijken voor