Freigeben über


ModuleBuilder.GetArrayMethod Methode

Definition

Gibt die benannte Methode für eine Arrayklasse zurück.

public:
 System::Reflection::MethodInfo ^ GetArrayMethod(Type ^ arrayClass, System::String ^ methodName, System::Reflection::CallingConventions callingConvention, Type ^ returnType, cli::array <Type ^> ^ parameterTypes);
public System.Reflection.MethodInfo GetArrayMethod (Type arrayClass, string methodName, System.Reflection.CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes);
public System.Reflection.MethodInfo GetArrayMethod (Type arrayClass, string methodName, System.Reflection.CallingConventions callingConvention, Type returnType, Type[] parameterTypes);
member this.GetArrayMethod : Type * string * System.Reflection.CallingConventions * Type * Type[] -> System.Reflection.MethodInfo
Public Function GetArrayMethod (arrayClass As Type, methodName As String, callingConvention As CallingConventions, returnType As Type, parameterTypes As Type()) As MethodInfo

Parameter

arrayClass
Type

Eine Arrayklasse.

methodName
String

Der Name einer Methode für eine Arrayklasse.

callingConvention
CallingConventions

Die Aufrufkonvention der Methode.

returnType
Type

Der Rückgabetyp der Methode.

parameterTypes
Type[]

Die Typen der Parameter der Methode.

Gibt zurück

Die benannte Methode für eine Arrayklasse.

Ausnahmen

arrayClass ist kein Array.

arrayClass oder methodName ist null.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie sie verwenden GetArrayMethod , um die MethodInfo entsprechende Methode abzurufen, die einen Arraywert zurückgibt.

// Define a dynamic module in "TempAssembly" assembly.
ModuleBuilder^ myModuleBuilder = myAssemblyBuilder->
   DefineDynamicModule( "TempModule" );

// Define a runtime class with specified name and attributes.
TypeBuilder^ myTypeBuilder = myModuleBuilder->DefineType(
   "TempClass", TypeAttributes::Public );
array<Type^>^ paramArray = { Array::typeid };
// Add 'SortArray' method to the class, with the given signature.
MethodBuilder^ myMethod = myTypeBuilder->DefineMethod( "SortArray",
   MethodAttributes::Public, Array::typeid, paramArray );

array<Type^>^ myArrayClass = gcnew array<Type^>( 1 );
array<Type^>^ parameterTypes = { Array::typeid };
// Get the 'MethodInfo' object corresponding to 'Sort' method of 'Array' class.
MethodInfo^ myMethodInfo = myModuleBuilder->GetArrayMethod(
   myArrayClass->GetType(), "Sort", CallingConventions::Standard,
   nullptr, parameterTypes );

// Get the token corresponding to 'Sort' method of 'Array' class.
MethodToken myMethodToken = myModuleBuilder->GetArrayMethodToken(
   myArrayClass->GetType(), "Sort", CallingConventions::Standard,
   nullptr, parameterTypes );
Console::WriteLine( "Token used by module to identify the 'Sort' method"
   + " of 'Array' class is : {0:x} ", myMethodToken.Token );

ILGenerator^ methodIL = myMethod->GetILGenerator();
methodIL->Emit( OpCodes::Ldarg_1 );
methodIL->Emit( OpCodes::Call, myMethodInfo );
methodIL->Emit( OpCodes::Ldarg_1 );
methodIL->Emit( OpCodes::Ret );

// Complete the creation of type.
myTypeBuilder->CreateType();
// Define a dynamic module in "TempAssembly" assembly.
ModuleBuilder myModuleBuilder = myAssemblyBuilder.
                              DefineDynamicModule("TempModule");
// Define a runtime class with specified name and attributes.
TypeBuilder myTypeBuilder = myModuleBuilder.DefineType
                           ("TempClass",TypeAttributes.Public);
Type[] paramArray = {typeof(Array)};
// Add 'SortArray' method to the class, with the given signature.
MethodBuilder myMethod = myTypeBuilder.DefineMethod("SortArray",
                          MethodAttributes.Public,typeof(Array),paramArray);

Type[] myArrayClass = new Type[1];
Type[] parameterTypes = {typeof(Array)};
// Get the 'MethodInfo' object corresponding to 'Sort' method of 'Array' class.
MethodInfo myMethodInfo=myModuleBuilder.GetArrayMethod(
            myArrayClass.GetType(),"Sort",CallingConventions.Standard,
                                                                         null,parameterTypes);
// Get the token corresponding to 'Sort' method of 'Array' class.
MethodToken myMethodToken=myModuleBuilder.GetArrayMethodToken(
            myArrayClass.GetType(),"Sort",CallingConventions.Standard,
                                                                        null,parameterTypes);
Console.WriteLine("Token used by module to identify the 'Sort' method"
                            + " of 'Array' class is : {0:x} ",myMethodToken.Token);

ILGenerator methodIL = myMethod.GetILGenerator();
methodIL.Emit(OpCodes.Ldarg_1);
methodIL.Emit(OpCodes.Call,myMethodInfo);
methodIL.Emit(OpCodes.Ldarg_1);
methodIL.Emit(OpCodes.Ret);

// Complete the creation of type.
myTypeBuilder.CreateType();
' Define a dynamic module in "TempAssembly" assembly.
Dim myModuleBuilder As ModuleBuilder = myAssemblyBuilder.DefineDynamicModule("TempModule")
' Define a runtime class with specified name and attributes.
Dim myTypeBuilder As TypeBuilder = _
            myModuleBuilder.DefineType("TempClass", TypeAttributes.Public)
Dim myParamArray() As Type = New Type() {GetType(Array)}
' Add 'SortArray' method to the class, with the given signature.
Dim myMethod As MethodBuilder = _
   myTypeBuilder.DefineMethod("SortArray", MethodAttributes.Public, _
   GetType(Array), myParamArray)

Dim myArrayClass(0) As Type
Dim parameterTypes() As Type = New Type() {GetType(Array)}
' Get the 'MethodInfo' object corresponding to 'Sort' method of 'Array' class.
Dim myMethodInfo As MethodInfo = _
   myModuleBuilder.GetArrayMethod(myArrayClass.GetType(), "Sort", _
   CallingConventions.Standard, Nothing, parameterTypes)
' Get the token corresponding to 'Sort' method of 'Array' class.
Dim myMethodToken As MethodToken = _
      myModuleBuilder.GetArrayMethodToken(myArrayClass.GetType(), _
      "Sort", CallingConventions.Standard, Nothing, parameterTypes)
Console.WriteLine("Token used by module to identify the 'Sort' method" + _
                  " of 'Array' class is : {0:x} ", myMethodToken.Token)
Dim methodIL As ILGenerator = myMethod.GetILGenerator()
methodIL.Emit(OpCodes.Ldarg_1)
methodIL.Emit(OpCodes.Call, myMethodInfo)
methodIL.Emit(OpCodes.Ldarg_1)
methodIL.Emit(OpCodes.Ret)
' Complete the creation of type.
myTypeBuilder.CreateType()

Hinweise

GetArrayMethod ist nützlich, wenn Sie über ein Array eines Typs verfügen, dessen Definition noch nicht abgeschlossen wurde und Sie auf methoden zugreifen möchten, die für Arraydefiniert sind. Beispielsweise können Sie einen Typ definieren und eine Methode definieren, die ein Array des Typs als Parameter akzeptiert. Um auf die Elemente des Arrays zuzugreifen, müssen Sie Methoden der Array -Klasse aufrufen.

Gilt für: