Cara: Menentukan dan menjalankan metode dinamis

Prosedur berikut menunjukkan cara mendefinisikan dan mengeksekusi metode dinamis sederhana dan metode dinamis yang terikat ke instans kelas. Untuk informasi selengkapnya tentang metode dinamis, lihat DynamicMethod kelas .

1. Deklarasikan jenis delegasi untuk menjalankan metode. Pertimbangkan untuk menggunakan delegasi umum untuk meminimalkan jumlah jenis delegasi yang perlu Anda deklarasikan. Kode berikut mendeklarasikan dua tipe delegasi yang dapat digunakan untuk metode SquareIt, dan salah satunya adalah generik.

   private: 
       delegate long long SquareItInvoker(int input);
   
       generic<typename TReturn, typename TParameter0> 
           delegate TReturn OneParameter(TParameter0 p0);
   

   private delegate long SquareItInvoker(int input);
   
   private delegate TReturn OneParameter<TReturn, TParameter0>
       (TParameter0 p0);
   

   Private Delegate Function _
       SquareItInvoker(ByVal input As Integer) As Long
   
   Private Delegate Function _
       OneParameter(Of TReturn, TParameter0) _
       (ByVal p0 As TParameter0) As TReturn
   

2. Buat larik yang menentukan jenis parameter untuk metode dinamis. Dalam contoh ini, satu-satunya parameter adalah int (Integer dalam Visual Basic), sehingga larik hanya memiliki satu elemen.

   array<Type^>^ methodArgs = { int::typeid };
   

   Type[] methodArgs = {typeof(int)};
   

   Dim methodArgs As Type() = {GetType(Integer)}
   

3. Buat DynamicMethod. Dalam contoh ini metodenya bernama SquareIt.

   Catatan

   Tidak perlu memberi nama metode dinamis, dan ini tidak dapat dipanggil dengan nama. Beberapa metode dinamis dapat memiliki nama yang sama. Namun, nama tersebut muncul di tumpukan panggilan dan dapat berguna untuk penelusuran kesalahan.

   Jenis nilai kembalian ditetapkan sebagai long. Metode ini dikaitkan dengan modul yang berisi kelas Example, yang berisi kode contoh. Setiap modul yang dimuat dapat ditentukan. Metode dinamis bertindak seperti metode static tingkat modul (Shared dalam Visual Basic).

   DynamicMethod^ squareIt = gcnew DynamicMethod(
       "SquareIt", 
       long long::typeid, 
       methodArgs, 
       Example::typeid->Module);
   

   DynamicMethod squareIt = new DynamicMethod(
       "SquareIt",
       typeof(long),
       methodArgs,
       typeof(Example).Module);
   

   Dim squareIt As New DynamicMethod( _
       "SquareIt", _
       GetType(Long), _
       methodArgs, _
       GetType(Example).Module)
   

4. Keluarkan isi metode. Dalam contoh ini, ILGenerator objek digunakan untuk memancarkan bahasa perantara umum (CIL). Atau, objek DynamicILInfo dapat digunakan bersama dengan pembuat kode yang tidak dikelola untuk memancarkan badan metode untuk DynamicMethod.

   CIL dalam contoh ini memuat argumen, yang merupakan int, ke tumpukan, mengonversinya menjadi long, menduplikasi long, dan mengalikan dua angka. Ini meninggalkan hasil kuadrat pada tumpukan, dan semua metode yang harus dilakukan adalah kembali.

   ILGenerator^ il = squareIt->GetILGenerator();
   il->Emit(OpCodes::Ldarg_0);
   il->Emit(OpCodes::Conv_I8);
   il->Emit(OpCodes::Dup);
   il->Emit(OpCodes::Mul);
   il->Emit(OpCodes::Ret);
   

   ILGenerator il = squareIt.GetILGenerator();
   il.Emit(OpCodes.Ldarg_0);
   il.Emit(OpCodes.Conv_I8);
   il.Emit(OpCodes.Dup);
   il.Emit(OpCodes.Mul);
   il.Emit(OpCodes.Ret);
   

   Dim il As ILGenerator = squareIt.GetILGenerator()
   il.Emit(OpCodes.Ldarg_0)
   il.Emit(OpCodes.Conv_I8)
   il.Emit(OpCodes.Dup)
   il.Emit(OpCodes.Mul)
   il.Emit(OpCodes.Ret)
   

5. Buat instans dari delegasi (dideklarasikan pada langkah 1) yang mewakili metode dinamis dengan memanggil metode CreateDelegate. Membuat delegasi menyelesaikan metode, dan upaya lebih lanjut untuk mengubah metode — misalnya, menambahkan lebih banyak CIL — diabaikan. Kode berikut membuat delegasi dan memanggilnya, menggunakan delegasi umum.

   OneParameter<long long, int>^ invokeSquareIt = 
       (OneParameter<long long, int>^)
       squareIt->CreateDelegate(OneParameter<long long, int>::typeid);
   
   Console::WriteLine("123456789 squared = {0}",
       invokeSquareIt(123456789));
   

   OneParameter<long, int> invokeSquareIt =
       (OneParameter<long, int>)
       squareIt.CreateDelegate(typeof(OneParameter<long, int>));
   
   Console.WriteLine("123456789 squared = {0}",
       invokeSquareIt(123456789));
   

   Dim invokeSquareIt As OneParameter(Of Long, Integer) = _
       CType( _
           squareIt.CreateDelegate( _
               GetType(OneParameter(Of Long, Integer))), _
           OneParameter(Of Long, Integer) _
       )
   
   Console.WriteLine("123456789 squared = {0}", _
       invokeSquareIt(123456789))
   

6. Deklarasikan jenis delegasi untuk menjalankan metode. Pertimbangkan untuk menggunakan delegasi umum untuk meminimalkan jumlah jenis delegasi yang perlu Anda deklarasikan. Kode berikut mendeklarasikan jenis delegasi generik yang dapat digunakan untuk menjalankan metode apa pun dengan satu parameter dan nilai kembalian, atau metode dengan dua parameter dan nilai pengembalian jika delegasi terikat ke objek.

   generic<typename TReturn, typename TParameter0> 
       delegate TReturn OneParameter(TParameter0 p0);
   

   private delegate TReturn OneParameter<TReturn, TParameter0>
       (TParameter0 p0);
   

   Private Delegate Function _
       OneParameter(Of TReturn, TParameter0) _
       (ByVal p0 As TParameter0) As TReturn
   

7. Buat larik yang menentukan jenis parameter untuk metode dinamis. Jika delegasi yang mewakili metode akan diikat ke suatu objek, parameter pertama harus cocok dengan jenis yang diikat oleh delegasi. Dalam contoh ini, ada dua parameter, tipe Example dan tipe int (Integer dalam Visual Basic).

   array<Type^>^ methodArgs2 = { Example::typeid, int::typeid };
   

   Type[] methodArgs2 = { typeof(Example), typeof(int) };
   

   Dim methodArgs2 As Type() = _
       {GetType(Example), GetType(Integer)}
   

8. Buat DynamicMethod. Dalam contoh ini metode tidak memiliki nama. Jenis nilai kembalian ditetapkan sebagai int (Integer dalam Visual Basic). Metode ini memiliki akses ke anggota kelas Example pribadi dan yang dilindungi.

   DynamicMethod^ multiplyHidden = gcnew DynamicMethod(
       "", 
       int::typeid, 
       methodArgs2, 
       Example::typeid);
   

   DynamicMethod multiplyHidden = new DynamicMethod(
       "",
       typeof(int),
       methodArgs2,
       typeof(Example));
   

   Dim multiplyPrivate As New DynamicMethod( _
       "", _
       GetType(Integer), _
       methodArgs2, _
       GetType(Example))
   

9. Keluarkan isi metode. Dalam contoh ini, ILGenerator objek digunakan untuk memancarkan bahasa perantara umum (CIL). Atau, objek DynamicILInfo dapat digunakan bersama dengan pembuat kode yang tidak dikelola untuk memancarkan badan metode untuk DynamicMethod.

   CIL dalam contoh ini memuat argumen pertama, yang merupakan instans Example kelas, dan menggunakannya untuk memuat nilai bidang instans privat jenis int. Argumen kedua dimuat, dan dua angka dikalikan. Jika hasilnya lebih besar dari int, nilainya dipotong dan bit yang paling signifikan dibuang. Metode kembali, dengan nilai kembalian pada tumpukan.

   ILGenerator^ ilMH = multiplyHidden->GetILGenerator();
   ilMH->Emit(OpCodes::Ldarg_0);
   
   FieldInfo^ testInfo = Example::typeid->GetField("test",
       BindingFlags::NonPublic | BindingFlags::Instance);
   
   ilMH->Emit(OpCodes::Ldfld, testInfo);
   ilMH->Emit(OpCodes::Ldarg_1);
   ilMH->Emit(OpCodes::Mul);
   ilMH->Emit(OpCodes::Ret);
   

   ILGenerator ilMH = multiplyHidden.GetILGenerator();
   ilMH.Emit(OpCodes.Ldarg_0);
   
   FieldInfo testInfo = typeof(Example).GetField("test",
       BindingFlags.NonPublic | BindingFlags.Instance);
   
   ilMH.Emit(OpCodes.Ldfld, testInfo);
   ilMH.Emit(OpCodes.Ldarg_1);
   ilMH.Emit(OpCodes.Mul);
   ilMH.Emit(OpCodes.Ret);
   

   Dim ilMP As ILGenerator = multiplyPrivate.GetILGenerator()
   ilMP.Emit(OpCodes.Ldarg_0)
   
   Dim testInfo As FieldInfo = _
       GetType(Example).GetField("test", _
           BindingFlags.NonPublic Or BindingFlags.Instance)
   
   ilMP.Emit(OpCodes.Ldfld, testInfo)
   ilMP.Emit(OpCodes.Ldarg_1)
   ilMP.Emit(OpCodes.Mul)
   ilMP.Emit(OpCodes.Ret)
   

10. Buat instans dari delegasi (dideklarasikan pada langkah 1) yang mewakili metode dinamis dengan memanggil metode CreateDelegate(Type, Object) yang berlebihan. Membuat delegasi menyelesaikan metode, dan upaya lebih lanjut untuk mengubah metode—misalnya, menambahkan lebih banyak CIL—diabaikan.

    Catatan

    Anda dapat memanggil metode CreateDelegate beberapa kali untuk membuat delegasi yang terikat ke instans lain dari jenis target.

    Kode berikut mengikat metode ke instans baru dari kelas Example yang bidang pengujian pribadinya diatur ke 42. Artinya, setiap kali delegasi dipanggil, instans Example diteruskan ke parameter pertama metode tersebut.

    Delegasi OneParameter digunakan karena parameter pertama metode selalu menerima instans Example. Saat delegasi dipanggil, hanya parameter kedua yang diperlukan.

    OneParameter<int, int>^ invoke = (OneParameter<int, int>^)
        multiplyHidden->CreateDelegate(
            OneParameter<int, int>::typeid, 
            gcnew Example(42)
        );
    
    Console::WriteLine("3 * test = {0}", invoke(3));
    

    OneParameter<int, int> invoke = (OneParameter<int, int>)
        multiplyHidden.CreateDelegate(
            typeof(OneParameter<int, int>),
            new Example(42)
        );
    
    Console.WriteLine("3 * test = {0}", invoke(3));
    

    Dim invoke As OneParameter(Of Integer, Integer) = _
        CType( _
            multiplyPrivate.CreateDelegate( _
                GetType(OneParameter(Of Integer, Integer)), _
                new Example(42) _
            ), _
            OneParameter(Of Integer, Integer) _
        )
    
    Console.WriteLine("3 * test = {0}", invoke(3))
    

Contoh

Contoh kode berikut menunjukkan metode dinamis sederhana dan metode dinamis yang terikat ke instans kelas.

Metode dinamis sederhana mengambil satu argumen, bilangan bulat 32-bit, dan mengembalikan kuadrat 64-bit dari bilangan bulat itu. Delegasi generik digunakan untuk memanggil metode.

Metode dinamis kedua memiliki dua parameter, tipe Example dan tipe int (Integer dalam Visual Basic). Saat metode dinamis telah dibuat, metode tersebut terikat ke instans Example, menggunakan delegasi umum yang memiliki satu argumen berjenis int. Delegasi tidak memiliki argumen jenis Example karena parameter pertama metode selalu menerima instans terikat Example. Saat delegasi dipanggil, hanya argumen int yang diberikan. Metode dinamis ini mengakses bidang pribadi dari kelas Example dan mengembalikan produk bidang pribadi dan argumen int.

Contoh kode mendefinisikan delegasi yang dapat digunakan untuk menjalankan metode.

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

public ref class Example
{
    // The following constructor and private field are used to
    // demonstrate a method bound to an object.
private:
    int test;
    
public:
    Example(int test) { this->test = test; }

    // Declare delegates that can be used to execute the completed 
    // SquareIt dynamic method. The OneParameter delegate can be 
    // used to execute any method with one parameter and a return
    // value, or a method with two parameters and a return value
    // if the delegate is bound to an object.
    //
private: 
    delegate long long SquareItInvoker(int input);

    generic<typename TReturn, typename TParameter0> 
        delegate TReturn OneParameter(TParameter0 p0);

public:
    static void Main()
    {
        // Example 1: A simple dynamic method.
        //
        // Create an array that specifies the parameter types for the
        // dynamic method. In this example the only parameter is an 
        // int, so the array has only one element.
        //
        array<Type^>^ methodArgs = { int::typeid };

        // Create a DynamicMethod. In this example the method is
        // named SquareIt. It is not necessary to give dynamic 
        // methods names. They cannot be invoked by name, and two
        // dynamic methods can have the same name. However, the 
        // name appears in calls stacks and can be useful for
        // debugging. 
        //
        // In this example the return type of the dynamic method is
        // long long. The method is associated with the module that 
        // contains the Example class. Any loaded module could be
        // specified. The dynamic method is like a module-level
        // static method.
        //
        DynamicMethod^ squareIt = gcnew DynamicMethod(
            "SquareIt", 
            long long::typeid, 
            methodArgs, 
            Example::typeid->Module);

        // Emit the method body. In this example ILGenerator is used
        // to emit the MSIL. DynamicMethod has an associated type
        // DynamicILInfo that can be used in conjunction with 
        // unmanaged code generators.
        //
        // The MSIL loads the argument, which is an int, onto the 
        // stack, converts the int to a long long, duplicates the top
        // item on the stack, and multiplies the top two items on the
        // stack. This leaves the squared number on the stack, and 
        // all the method has to do is return.
        //
        ILGenerator^ il = squareIt->GetILGenerator();
        il->Emit(OpCodes::Ldarg_0);
        il->Emit(OpCodes::Conv_I8);
        il->Emit(OpCodes::Dup);
        il->Emit(OpCodes::Mul);
        il->Emit(OpCodes::Ret);

        // Create a delegate that represents the dynamic method. 
        // Creating the delegate completes the method, and any further 
        // attempts to change the method (for example, by adding more
        // MSIL) are ignored. The following code uses a generic 
        // delegate that can produce delegate types matching any
        // single-parameter method that has a return type.
        //
        OneParameter<long long, int>^ invokeSquareIt = 
            (OneParameter<long long, int>^)
            squareIt->CreateDelegate(OneParameter<long long, int>::typeid);

        Console::WriteLine("123456789 squared = {0}",
            invokeSquareIt(123456789));

        // Example 2: A dynamic method bound to an instance.
        //
        // Create an array that specifies the parameter types for a
        // dynamic method. If the delegate representing the method
        // is to be bound to an object, the first parameter must 
        // match the type the delegate is bound to. In the following
        // code the bound instance is of the Example class. 
        //
        array<Type^>^ methodArgs2 = { Example::typeid, int::typeid };

        // Create a DynamicMethod. In this example the method has no
        // name. The return type of the method is int. The method 
        // has access to the protected and private data of the 
        // Example class.
        //
        DynamicMethod^ multiplyHidden = gcnew DynamicMethod(
            "", 
            int::typeid, 
            methodArgs2, 
            Example::typeid);

        // Emit the method body. In this example ILGenerator is used
        // to emit the MSIL. DynamicMethod has an associated type
        // DynamicILInfo that can be used in conjunction with 
        // unmanaged code generators.
        //
        // The MSIL loads the first argument, which is an instance of
        // the Example class, and uses it to load the value of a 
        // private instance field of type int. The second argument is
        // loaded, and the two numbers are multiplied. If the result
        // is larger than int, the value is truncated and the most 
        // significant bits are discarded. The method returns, with
        // the return value on the stack.
        //
        ILGenerator^ ilMH = multiplyHidden->GetILGenerator();
        ilMH->Emit(OpCodes::Ldarg_0);

        FieldInfo^ testInfo = Example::typeid->GetField("test",
            BindingFlags::NonPublic | BindingFlags::Instance);

        ilMH->Emit(OpCodes::Ldfld, testInfo);
        ilMH->Emit(OpCodes::Ldarg_1);
        ilMH->Emit(OpCodes::Mul);
        ilMH->Emit(OpCodes::Ret);

        // Create a delegate that represents the dynamic method. 
        // Creating the delegate completes the method, and any further 
        // attempts to change the method � for example, by adding more
        // MSIL � are ignored. 
        // 
        // The following code binds the method to a new instance
        // of the Example class whose private test field is set to 42.
        // That is, each time the delegate is invoked the instance of
        // Example is passed to the first parameter of the method.
        //
        // The delegate OneParameter is used, because the first
        // parameter of the method receives the instance of Example.
        // When the delegate is invoked, only the second parameter is
        // required. 
        //
        OneParameter<int, int>^ invoke = (OneParameter<int, int>^)
            multiplyHidden->CreateDelegate(
                OneParameter<int, int>::typeid, 
                gcnew Example(42)
            );

        Console::WriteLine("3 * test = {0}", invoke(3));
    }
};

void main()
{
    Example::Main();
}
/* This code example produces the following output:

123456789 squared = 15241578750190521
3 * test = 126
 */

using System;
using System.Reflection;
using System.Reflection.Emit;

public class Example
{
    // The following constructor and private field are used to
    // demonstrate a method bound to an object.
    private int test;
    public Example(int test) { this.test = test; }

    // Declare delegates that can be used to execute the completed
    // SquareIt dynamic method. The OneParameter delegate can be
    // used to execute any method with one parameter and a return
    // value, or a method with two parameters and a return value
    // if the delegate is bound to an object.
    //
    private delegate long SquareItInvoker(int input);

    private delegate TReturn OneParameter<TReturn, TParameter0>
        (TParameter0 p0);

    public static void Main()
    {
        // Example 1: A simple dynamic method.
        //
        // Create an array that specifies the parameter types for the
        // dynamic method. In this example the only parameter is an
        // int, so the array has only one element.
        //
        Type[] methodArgs = {typeof(int)};

        // Create a DynamicMethod. In this example the method is
        // named SquareIt. It is not necessary to give dynamic
        // methods names. They cannot be invoked by name, and two
        // dynamic methods can have the same name. However, the
        // name appears in calls stacks and can be useful for
        // debugging.
        //
        // In this example the return type of the dynamic method
        // is long. The method is associated with the module that
        // contains the Example class. Any loaded module could be
        // specified. The dynamic method is like a module-level
        // static method.
        //
        DynamicMethod squareIt = new DynamicMethod(
            "SquareIt",
            typeof(long),
            methodArgs,
            typeof(Example).Module);

        // Emit the method body. In this example ILGenerator is used
        // to emit the MSIL. DynamicMethod has an associated type
        // DynamicILInfo that can be used in conjunction with
        // unmanaged code generators.
        //
        // The MSIL loads the argument, which is an int, onto the
        // stack, converts the int to a long, duplicates the top
        // item on the stack, and multiplies the top two items on the
        // stack. This leaves the squared number on the stack, and
        // all the method has to do is return.
        //
        ILGenerator il = squareIt.GetILGenerator();
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Conv_I8);
        il.Emit(OpCodes.Dup);
        il.Emit(OpCodes.Mul);
        il.Emit(OpCodes.Ret);

        // Create a delegate that represents the dynamic method.
        // Creating the delegate completes the method, and any further
        // attempts to change the method (for example, by adding more
        // MSIL) are ignored. The following code uses a generic
        // delegate that can produce delegate types matching any
        // single-parameter method that has a return type.
        //
        OneParameter<long, int> invokeSquareIt =
            (OneParameter<long, int>)
            squareIt.CreateDelegate(typeof(OneParameter<long, int>));

        Console.WriteLine("123456789 squared = {0}",
            invokeSquareIt(123456789));

        // Example 2: A dynamic method bound to an instance.
        //
        // Create an array that specifies the parameter types for a
        // dynamic method. If the delegate representing the method
        // is to be bound to an object, the first parameter must
        // match the type the delegate is bound to. In the following
        // code the bound instance is of the Example class.
        //
        Type[] methodArgs2 = { typeof(Example), typeof(int) };

        // Create a DynamicMethod. In this example the method has no
        // name. The return type of the method is int. The method
        // has access to the protected and private data of the
        // Example class.
        //
        DynamicMethod multiplyHidden = new DynamicMethod(
            "",
            typeof(int),
            methodArgs2,
            typeof(Example));

        // Emit the method body. In this example ILGenerator is used
        // to emit the MSIL. DynamicMethod has an associated type
        // DynamicILInfo that can be used in conjunction with
        // unmanaged code generators.
        //
        // The MSIL loads the first argument, which is an instance of
        // the Example class, and uses it to load the value of a
        // private instance field of type int. The second argument is
        // loaded, and the two numbers are multiplied. If the result
        // is larger than int, the value is truncated and the most
        // significant bits are discarded. The method returns, with
        // the return value on the stack.
        //
        ILGenerator ilMH = multiplyHidden.GetILGenerator();
        ilMH.Emit(OpCodes.Ldarg_0);

        FieldInfo testInfo = typeof(Example).GetField("test",
            BindingFlags.NonPublic | BindingFlags.Instance);

        ilMH.Emit(OpCodes.Ldfld, testInfo);
        ilMH.Emit(OpCodes.Ldarg_1);
        ilMH.Emit(OpCodes.Mul);
        ilMH.Emit(OpCodes.Ret);

        // Create a delegate that represents the dynamic method.
        // Creating the delegate completes the method, and any further
        // attempts to change the method — for example, by adding more
        // MSIL — are ignored.
        //
        // The following code binds the method to a new instance
        // of the Example class whose private test field is set to 42.
        // That is, each time the delegate is invoked the instance of
        // Example is passed to the first parameter of the method.
        //
        // The delegate OneParameter is used, because the first
        // parameter of the method receives the instance of Example.
        // When the delegate is invoked, only the second parameter is
        // required.
        //
        OneParameter<int, int> invoke = (OneParameter<int, int>)
            multiplyHidden.CreateDelegate(
                typeof(OneParameter<int, int>),
                new Example(42)
            );

        Console.WriteLine("3 * test = {0}", invoke(3));
    }
}
/* This code example produces the following output:

123456789 squared = 15241578750190521
3 * test = 126
 */

Imports System.Reflection
Imports System.Reflection.Emit

Public Class Example

    ' The following constructor and private field are used to
    ' demonstrate a method bound to an object.
    '
    Private test As Integer
    Public Sub New(ByVal test As Integer)
        Me.test = test
    End Sub

    ' Declare delegates that can be used to execute the completed 
    ' SquareIt dynamic method. The OneParameter delegate can be 
    ' used to execute any method with one parameter and a return
    ' value, or a method with two parameters and a return value
    ' if the delegate is bound to an object.
    '
    Private Delegate Function _
        SquareItInvoker(ByVal input As Integer) As Long

    Private Delegate Function _
        OneParameter(Of TReturn, TParameter0) _
        (ByVal p0 As TParameter0) As TReturn

    Public Shared Sub Main()

        ' Example 1: A simple dynamic method.
        '
        ' Create an array that specifies the parameter types for the
        ' dynamic method. In this example the only parameter is an 
        ' Integer, so the array has only one element.
        '
        Dim methodArgs As Type() = {GetType(Integer)}

        ' Create a DynamicMethod. In this example the method is
        ' named SquareIt. It is not necessary to give dynamic 
        ' methods names. They cannot be invoked by name, and two
        ' dynamic methods can have the same name. However, the 
        ' name appears in calls stacks and can be useful for
        ' debugging. 
        '
        ' In this example the return type of the dynamic method
        ' is Long. The method is associated with the module that 
        ' contains the Example class. Any loaded module could be
        ' specified. The dynamic method is like a module-level
        ' Shared method.
        '
        Dim squareIt As New DynamicMethod( _
            "SquareIt", _
            GetType(Long), _
            methodArgs, _
            GetType(Example).Module)

        ' Emit the method body. In this example ILGenerator is used
        ' to emit the MSIL. DynamicMethod has an associated type
        ' DynamicILInfo that can be used in conjunction with 
        ' unmanaged code generators.
        '
        ' The MSIL loads the argument, which is an Integer, onto the 
        ' stack, converts the Integer to a Long, duplicates the top
        ' item on the stack, and multiplies the top two items on the
        ' stack. This leaves the squared number on the stack, and 
        ' all the method has to do is return.
        '
        Dim il As ILGenerator = squareIt.GetILGenerator()
        il.Emit(OpCodes.Ldarg_0)
        il.Emit(OpCodes.Conv_I8)
        il.Emit(OpCodes.Dup)
        il.Emit(OpCodes.Mul)
        il.Emit(OpCodes.Ret)

        ' Create a delegate that represents the dynamic method. 
        ' Creating the delegate completes the method, and any further 
        ' attempts to change the method (for example, by adding more
        ' MSIL) are ignored. The following code uses a generic 
        ' delegate that can produce delegate types matching any
        ' single-parameter method that has a return type.
        '
        Dim invokeSquareIt As OneParameter(Of Long, Integer) = _
            CType( _
                squareIt.CreateDelegate( _
                    GetType(OneParameter(Of Long, Integer))), _
                OneParameter(Of Long, Integer) _
            )

        Console.WriteLine("123456789 squared = {0}", _
            invokeSquareIt(123456789))


        ' Example 2: A dynamic method bound to an instance.
        '
        ' Create an array that specifies the parameter types for a
        ' dynamic method. If the delegate representing the method
        ' is to be bound to an object, the first parameter must 
        ' match the type the delegate is bound to. In the following
        ' code the bound instance is of the Example class. 
        '
        Dim methodArgs2 As Type() = _
            {GetType(Example), GetType(Integer)}

        ' Create a DynamicMethod. In this example the method has no
        ' name. The return type of the method is Integer. The method 
        ' has access to the protected and private members of the 
        ' Example class. 
        '
        Dim multiplyPrivate As New DynamicMethod( _
            "", _
            GetType(Integer), _
            methodArgs2, _
            GetType(Example))

        ' Emit the method body. In this example ILGenerator is used
        ' to emit the MSIL. DynamicMethod has an associated type
        ' DynamicILInfo that can be used in conjunction with 
        ' unmanaged code generators.
        '
        ' The MSIL loads the first argument, which is an instance of
        ' the Example class, and uses it to load the value of a 
        ' private instance field of type Integer. The second argument 
        ' is loaded, and the two numbers are multiplied. If the result
        ' is larger than Integer, the value is truncated and the most 
        ' significant bits are discarded. The method returns, with
        ' the return value on the stack.
        '
        Dim ilMP As ILGenerator = multiplyPrivate.GetILGenerator()
        ilMP.Emit(OpCodes.Ldarg_0)

        Dim testInfo As FieldInfo = _
            GetType(Example).GetField("test", _
                BindingFlags.NonPublic Or BindingFlags.Instance)

        ilMP.Emit(OpCodes.Ldfld, testInfo)
        ilMP.Emit(OpCodes.Ldarg_1)
        ilMP.Emit(OpCodes.Mul)
        ilMP.Emit(OpCodes.Ret)

        ' Create a delegate that represents the dynamic method. 
        ' Creating the delegate completes the method, and any further 
        ' attempts to change the method  for example, by adding more
        ' MSIL  are ignored. 
        ' 
        ' The following code binds the method to a new instance
        ' of the Example class whose private test field is set to 42.
        ' That is, each time the delegate is invoked the instance of
        ' Example is passed to the first parameter of the method.
        '
        ' The delegate OneParameter is used, because the first
        ' parameter of the method receives the instance of Example.
        ' When the delegate is invoked, only the second parameter is
        ' required. 
        '
        Dim invoke As OneParameter(Of Integer, Integer) = _
            CType( _
                multiplyPrivate.CreateDelegate( _
                    GetType(OneParameter(Of Integer, Integer)), _
                    new Example(42) _
                ), _
                OneParameter(Of Integer, Integer) _
            )

        Console.WriteLine("3 * test = {0}", invoke(3))

    End Sub

End Class

' This code example produces the following output:
'
'123456789 squared = 15241578750190521
'3 * test = 126
' 

Lihat juga

• DynamicMethod