ModuleBuilder.GetArrayMethod Method

Parameters

• arrayClass
  Type: System.Type
  An array class.

• methodName
  Type: System.String
  The name of a method on the array class.

• callingConvention
  Type: System.Reflection.CallingConventions
  The method's calling convention.

• returnType
  Type: System.Type
  The return type of the method.

• parameterTypes
  Type: array<System.Type[]
  The types of the method's parameters.

Return Value

Type: System.Reflection.MethodInfo
The named method on an array class.

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Security.Permissions

Public Class Example

   Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)

      Dim myCurrentDomain As AppDomain = AppDomain.CurrentDomain
      Dim myAssemblyName As New AssemblyName("TempAssembly")

      ' Define a dynamic assembly in the current application domain.
      Dim myAssemblyBuilder As AssemblyBuilder = _
            myCurrentDomain.DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.Run)
      ' 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)

      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.
      Dim myType As Type = myTypeBuilder.CreateType()

      Dim myObject As Object = Activator.CreateInstance(myType)
      Dim sortArray As MethodInfo = myType.GetMethod("SortArray")
      If Not sortArray Is Nothing Then
         Dim arrayToSort As String() = {"I", "am", "not", "sorted"}
         outputBlock.Text &= "Array elements before sorting " & vbCrLf
         Dim i As Integer
         For i = 0 To arrayToSort.Length - 1
            outputBlock.Text &= String.Format("Array element {0} : {1}" & vbCrLf, _
               i, arrayToSort(i))
         Next i
         Dim arguments() As Object = New Object() {arrayToSort}
         outputBlock.Text &= "Invoking our dynamically " + _
                           "created SortArray method..." & vbCrLf
         Dim myOutput As Object = sortArray.Invoke(myObject, arguments)
         Dim mySortedArray As String() = CType(myOutput, String())
         outputBlock.Text &= "Array elements after sorting " & vbCrLf
         Dim j As Integer
         For j = 0 To mySortedArray.Length - 1
            outputBlock.Text &= String.Format("Array element {0} : {1}" & vbCrLf, _
               j, mySortedArray(j)) 
         Next j
      End If
   End Sub 
End Class 

' This example produces the following output:
'
'Array elements before sorting
'Array element 0 : I
'Array element 1 : am
'Array element 2 : not
'Array element 3 : sorted
'Invoking the dynamically created SortArray method...
'Array element 1 : am
'Array element 0 : I
'Array element 2 : not
'Array element 3 : sorted

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Security.Permissions;

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      AppDomain myCurrentDomain = AppDomain.CurrentDomain;
      AssemblyName myAssemblyName = new AssemblyName("TempAssembly");

      // Define a dynamic assembly in the current application domain.
      AssemblyBuilder myAssemblyBuilder = myCurrentDomain.DefineDynamicAssembly
                     (myAssemblyName, AssemblyBuilderAccess.Run);
      // 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);

      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.
      Type myType = myTypeBuilder.CreateType();

      object myObject = Activator.CreateInstance(myType);
      MethodInfo sortArray = myType.GetMethod("SortArray");
      if (null != sortArray)
      {
         string[] arrayToSort = { "I", "am", "not", "sorted" };
         outputBlock.Text += "Array elements before sorting " + "\n";
         for (int i = 0; i < arrayToSort.Length; i++)
         {
            outputBlock.Text += 
               String.Format("Array element {0} : {1}\n", i, arrayToSort[i]);
         }
         object[] arguments = { arrayToSort };
         outputBlock.Text += "Invoking the dynamically created SortArray method...\n";
         object myOutput = sortArray.Invoke(myObject, arguments);
         String[] mySortedArray = (String[])myOutput;
         outputBlock.Text += "Array elements after sorting " + "\n";
         for (int i = 0; i < mySortedArray.Length; i++)
         {
            outputBlock.Text += 
               String.Format("Array element {0} : {1}\n", i, mySortedArray[i]);
         }
      }
   }
}

/* This example produces the following output:

Array elements before sorting
Array element 0 : I
Array element 1 : am
Array element 2 : not
Array element 3 : sorted
Invoking the dynamically created SortArray method...
Array element 1 : am
Array element 0 : I
Array element 2 : not
Array element 3 : sorted
 */