Cara: Menghubungkan delegasi menggunakan refleksi

Artikel
03/30/2024

Saat Anda menggunakan pantulan untuk memuat dan menjalankan rakitan, Anda tidak dapat menggunakan fitur bahasa seperti operator C# += atau pernyataan Visual Basic AddHandler untuk menghubungkan peristiwa. Prosedur berikut menunjukkan cara menghubungkan metode yang ada ke peristiwa dengan mendapatkan semua jenis yang diperlukan melalui refleksi, dan cara membuat metode dinamis menggunakan refleksi untuk memancarkan dan menghubungkannya ke peristiwa.

Catatan

Untuk cara lain menghubungkan delegasi penanganan peristiwa, lihat contoh kode untuk metode AddEventHandler kelas EventInfo.

Untuk menghubungkan delegasi menggunakan refleksi

Muat rakitan yang memuat jenis yang menaikkan peristiwa. Rakitan biasanya dimuat dengan metode Assembly.Load. Untuk menjaga contoh ini tetap sederhana, formulir turunan dalam rakitan saat ini digunakan, sehingga metode GetExecutingAssembly digunakan untuk memuat rakitan saat ini.
```
Assembly^ assem = Example::typeid->Assembly;
```
```
Assembly assem = typeof(Example).Assembly;
```
```
Dim assem As Assembly = GetType(Example).Assembly
```
Dapatkan objek Type yang mewakili jenis, dan buat instans jenis. Metode CreateInstance(Type) digunakan dalam kode berikut karena formulir memiliki konstruktor tanpa parameter. Terdapat beberapa kelebihan metode CreateInstance lain yang dapat Anda gunakan jika jenis yang Anda buat tidak memiliki konstruktor tanpa parameter. Instans baru disimpan sebagai jenis Object untuk mempertahankan fiksi bahwa tidak ada yang diketahui tentang rakitan. (Refleksi mengizinkan Anda untuk mendapatkan jenis dalam rakitan tanpa mengetahui namanya terlebih dahulu.)
```
Type^ tExForm = assem->GetType("ExampleForm");
Object^ exFormAsObj = Activator::CreateInstance(tExForm);
```
```
Type tExForm = assem.GetType("ExampleForm");
Object exFormAsObj = Activator.CreateInstance(tExForm);
```
```
Dim tExForm As Type = assem.GetType("ExampleForm")
Dim exFormAsObj As Object = _
    Activator.CreateInstance(tExForm)
```

Dapatkan objek EventInfo yang mewakili peristiwa, dan gunakan properti EventHandlerType untuk mendapatkan jenis delegasi yang digunakan untuk menangani peristiwa. Dalam kode berikut, EventInfo untuk peristiwa Click diperoleh.

EventInfo^ evClick = tExForm->GetEvent("Click");
Type^ tDelegate = evClick->EventHandlerType;

EventInfo evClick = tExForm.GetEvent("Click");
Type tDelegate = evClick.EventHandlerType;

Dim evClick As EventInfo = tExForm.GetEvent("Click")
Dim tDelegate As Type = evClick.EventHandlerType

Dapatkan objek MethodInfo yang mewakili metode yang menangani peristiwa. Kode program lengkap di bagian Contoh nanti dalam artikel ini berisi metode yang cocok dengan tanda tangan EventHandler delegasi, yang menangani Click peristiwa, tetapi Anda juga dapat menghasilkan metode dinamis pada waktu proses. Untuk rinciannya, lihat prosedur yang menyertainya, untuk menghasilkan penanganan aktivitas pada durasi dengan menggunakan metode dinamis.
```
MethodInfo^ miHandler =
    Type::GetType("Example")->GetMethod("LuckyHandler",
        BindingFlags::NonPublic | BindingFlags::Instance);
```
```
MethodInfo miHandler =
    typeof(Example).GetMethod("LuckyHandler",
        BindingFlags.NonPublic | BindingFlags.Instance);
```
```
Dim miHandler As MethodInfo = _
    GetType(Example).GetMethod("LuckyHandler", _
        BindingFlags.NonPublic Or BindingFlags.Instance)
```
Buat instans delegasi, menggunakan metode CreateDelegate. Metode ini bersifat statis (Shared dalam Visual Basic), sehingga jenis delegasi harus disediakan. Disarankan menggunakan kelebihan CreateDelegate yang mengambil MethodInfo.
```
Delegate^ d = Delegate::CreateDelegate(tDelegate, this, miHandler);
```
```
Delegate d = Delegate.CreateDelegate(tDelegate, this, miHandler);
```
```
Dim d As [Delegate] = _
    [Delegate].CreateDelegate(tDelegate, Me, miHandler)
```
Dapatkan metode aksesor add dan panggil untuk menghubungkan peristiwa. Semua peristiwa memiliki aksesor add dan aksesor remove, yang disembunyikan oleh sintaks bahasa tingkat tinggi. Contohnya, C# menggunakan operator += untuk menghubungkan peristiwa, dan Visual Basic menggunakan pernyataan AddHandler. Kode berikut mendapatkan aksesor add peristiwa Click dan memanggilnya terlambat, meneruskan instans delegasi. Argumen harus diteruskan sebagai array.
```
MethodInfo^ addHandler = evClick->GetAddMethod();
array<Object^>^ addHandlerArgs = { d };
addHandler->Invoke(exFormAsObj, addHandlerArgs);
```
```
MethodInfo addHandler = evClick.GetAddMethod();
Object[] addHandlerArgs = { d };
addHandler.Invoke(exFormAsObj, addHandlerArgs);
```
```
Dim miAddHandler As MethodInfo = evClick.GetAddMethod()
Dim addHandlerArgs() As Object = {d}
miAddHandler.Invoke(exFormAsObj, addHandlerArgs)
```
Uji peristiwa. Kode berikut menunjukkan formulir yang ditentukan dalam contoh kode. Mengeklik formulir memanggil penanganan aktivitas.
```
Application::Run((Form^) exFormAsObj);
```
```
Application.Run((Form) exFormAsObj);
```
```
Application.Run(CType(exFormAsObj, Form))
```

Membuat penanganan aktivitas pada waktu proses dengan menggunakan metode dinamis

Metode penanganan aktivitas dapat dihasilkan pada durasi, menggunakan metode dinamis ringan dan pancaran refleksi. Untuk membuat penanganan aktivitas, Anda memerlukan jenis pengembalian dan jenis parameter delegasi. Jenis-jenis ini dapat diperoleh dengan memeriksa metode delegasi Invoke. Kode berikut menggunakan metode GetDelegateReturnType dan GetDelegateParameterTypes untuk mendapatkan informasi ini. Kode untuk metode ini dapat ditemukan di bagian Contoh nanti di artikel ini.

Tidak perlu memberi nama DynamicMethod, sehingga string kosong dapat digunakan. Dalam kode berikut, argumen terakhir mengaitkan metode dinamis dengan jenis saat ini, memberikan akses delegasi ke semua anggota publik dan privat dari kelas Example.

Type^ returnType = GetDelegateReturnType(tDelegate);
if (returnType != void::typeid)
    throw gcnew ApplicationException("Delegate has a return type.");
    
DynamicMethod^ handler =
    gcnew DynamicMethod("",
                      nullptr,
                      GetDelegateParameterTypes(tDelegate),
                      Example::typeid);

Type returnType = GetDelegateReturnType(tDelegate);
if (returnType != typeof(void))
    throw new ArgumentException("Delegate has a return type.", nameof(d));

DynamicMethod handler =
    new DynamicMethod("",
                      null,
                      GetDelegateParameterTypes(tDelegate),
                      typeof(Example));

Dim returnType As Type = GetDelegateReturnType(tDelegate)
If returnType IsNot GetType(Void) Then
    Throw New ArgumentException("Delegate has a return type.", NameOf(d))
End If

Dim handler As New DynamicMethod( _
    "", _
    Nothing, _
    GetDelegateParameterTypes(tDelegate), _
    GetType(Example) _
)

Hasilkan isi metode. Metode ini memuat string, memanggil kelebihan metode MessageBox.Show yang mengambil string, memunculkan nilai yang dikembalikan dari tumpukan (karena penangan tidak memiliki jenis pengembalian), dan mengembalikan. Untuk mempelajari selengkapnya tentang memancarkan metode dinamis, lihat Cara: Menentukan dan Menjalankan Metode Dinamis.

ILGenerator^ ilgen = handler->GetILGenerator();

array<Type^>^ showParameters = { String::typeid };
MethodInfo^ simpleShow =
    MessageBox::typeid->GetMethod("Show", showParameters);

ilgen->Emit(OpCodes::Ldstr,
    "This event handler was constructed at run time.");
ilgen->Emit(OpCodes::Call, simpleShow);
ilgen->Emit(OpCodes::Pop);
ilgen->Emit(OpCodes::Ret);

ILGenerator ilgen = handler.GetILGenerator();

Type[] showParameters = { typeof(String) };
MethodInfo simpleShow =
    typeof(MessageBox).GetMethod("Show", showParameters);

ilgen.Emit(OpCodes.Ldstr,
    "This event handler was constructed at run time.");
ilgen.Emit(OpCodes.Call, simpleShow);
ilgen.Emit(OpCodes.Pop);
ilgen.Emit(OpCodes.Ret);

Dim ilgen As ILGenerator = handler.GetILGenerator()

Dim showParameters As Type() = {GetType(String)}
Dim simpleShow As MethodInfo = _
    GetType(MessageBox).GetMethod("Show", showParameters)

ilgen.Emit(OpCodes.Ldstr, _
    "This event handler was constructed at run time.")
ilgen.Emit(OpCodes.Call, simpleShow)
ilgen.Emit(OpCodes.Pop)
ilgen.Emit(OpCodes.Ret)

Selesaikan metode dinamis dengan memanggil metode CreateDelegate. Gunakan aksesor add untuk menambahkan delegasi ke daftar pemanggilan untuk peristiwa tersebut.

Delegate^ dEmitted = handler->CreateDelegate(tDelegate);
addHandler->Invoke(exFormAsObj, gcnew array<Object^> { dEmitted });

Delegate dEmitted = handler.CreateDelegate(tDelegate);
addHandler.Invoke(exFormAsObj, new Object[] { dEmitted });

Dim dEmitted As [Delegate] = handler.CreateDelegate(tDelegate)
miAddHandler.Invoke(exFormAsObj, New Object() {dEmitted})

Uji peristiwa. Kode berikut memuat formulir yang ditentukan dalam contoh kode. Mengeklik formulir memanggil penanganan aktivitas yang telah ditentukan dan penanganan aktivitas yang dipancarkan.
```
Application::Run((Form^) exFormAsObj);
```
```
Application.Run((Form) exFormAsObj);
```
```
Application.Run(CType(exFormAsObj, Form))
```

Contoh

Contoh kode berikut menunjukkan cara menghubungkan metode yang ada ke peristiwa menggunakan refleksi, dan juga cara menggunakan kelas DynamicMethod untuk memancarkan metode pada durasi dan menghubungkannya ke peristiwa.

#using <System.dll>
#using <System.Windows.Forms.dll>

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Windows::Forms;

public ref class ExampleForm : public Form
{
public:
    ExampleForm() : Form()
    {
        this->Text = "Click me";
    }
};

public ref class Example
{
public:
    static void Main()
    {
        Example^ ex = gcnew Example();
        ex->HookUpDelegate();
    }

private:
    void HookUpDelegate()
    {
        // Load an assembly, for example using the Assembly.Load
        // method. In this case, the executing assembly is loaded, to
        // keep the demonstration simple.
        //
        Assembly^ assem = Example::typeid->Assembly;

        // Get the type that is to be loaded, and create an instance
        // of it. Activator::CreateInstance has other overloads, if
        // the type lacks a default constructor. The new instance
        // is stored as type Object, to maintain the fiction that
        // nothing is known about the assembly. (Note that you can
        // get the types in an assembly without knowing their names
        // in advance.)
        //
        Type^ tExForm = assem->GetType("ExampleForm");
        Object^ exFormAsObj = Activator::CreateInstance(tExForm);

        // Get an EventInfo representing the Click event, and get the
        // type of delegate that handles the event.
        //
        EventInfo^ evClick = tExForm->GetEvent("Click");
        Type^ tDelegate = evClick->EventHandlerType;

        // If you already have a method with the correct signature,
        // you can simply get a MethodInfo for it. 
        //
        MethodInfo^ miHandler =
            Type::GetType("Example")->GetMethod("LuckyHandler",
                BindingFlags::NonPublic | BindingFlags::Instance);
            
        // Create an instance of the delegate. Using the overloads
        // of CreateDelegate that take MethodInfo is recommended.
        //
        Delegate^ d = Delegate::CreateDelegate(tDelegate, this, miHandler);

        // Get the "add" accessor of the event and invoke it late-
        // bound, passing in the delegate instance. This is equivalent
        // to using the += operator in C#, or AddHandler in Visual
        // Basic. The instance on which the "add" accessor is invoked
        // is the form; the arguments must be passed as an array.
        //
        MethodInfo^ addHandler = evClick->GetAddMethod();
        array<Object^>^ addHandlerArgs = { d };
        addHandler->Invoke(exFormAsObj, addHandlerArgs);

        // Event handler methods can also be generated at run time,
        // using lightweight dynamic methods and Reflection.Emit.
        // To construct an event handler, you need the return type
        // and parameter types of the delegate. These can be obtained
        // by examining the delegate's Invoke method. 
        //
        // It is not necessary to name dynamic methods, so the empty 
        // string can be used. The last argument associates the 
        // dynamic method with the current type, giving the delegate
        // access to all the public and private members of Example,
        // as if it were an instance method.
        //
        Type^ returnType = GetDelegateReturnType(tDelegate);
        if (returnType != void::typeid)
            throw gcnew ApplicationException("Delegate has a return type.");
            
        DynamicMethod^ handler =
            gcnew DynamicMethod("",
                              nullptr,
                              GetDelegateParameterTypes(tDelegate),
                              Example::typeid);

        // Generate a method body. This method loads a string, calls 
        // the Show method overload that takes a string, pops the
        // return value off the stack (because the handler has no
        // return type), and returns.
        //
        ILGenerator^ ilgen = handler->GetILGenerator();

        array<Type^>^ showParameters = { String::typeid };
        MethodInfo^ simpleShow =
            MessageBox::typeid->GetMethod("Show", showParameters);

        ilgen->Emit(OpCodes::Ldstr,
            "This event handler was constructed at run time.");
        ilgen->Emit(OpCodes::Call, simpleShow);
        ilgen->Emit(OpCodes::Pop);
        ilgen->Emit(OpCodes::Ret);

        // Complete the dynamic method by calling its CreateDelegate
        // method. Use the "add" accessor to add the delegate to
        // the invocation list for the event.
        //
        Delegate^ dEmitted = handler->CreateDelegate(tDelegate);
        addHandler->Invoke(exFormAsObj, gcnew array<Object^> { dEmitted });

        // Show the form. Clicking on the form causes the two
        // delegates to be invoked.
        //
        Application::Run((Form^) exFormAsObj);
    }

    void LuckyHandler(Object^ sender, EventArgs^ e)
    {
        MessageBox::Show("This event handler just happened to be lying around.");
    }

    array<Type^>^ GetDelegateParameterTypes(Type^ d)
    {
        if (d->BaseType != MulticastDelegate::typeid)
            throw gcnew ApplicationException("Not a delegate.");

        MethodInfo^ invoke = d->GetMethod("Invoke");
        if (invoke == nullptr)
            throw gcnew ApplicationException("Not a delegate.");

        array<ParameterInfo^>^ parameters = invoke->GetParameters();
        array<Type^>^ typeParameters = gcnew array<Type^>(parameters->Length);
        for (int i = 0; i < parameters->Length; i++)
        {
            typeParameters[i] = parameters[i]->ParameterType;
        }
        return typeParameters;
    }

    Type^ GetDelegateReturnType(Type^ d)
    {
        if (d->BaseType != MulticastDelegate::typeid)
            throw gcnew ApplicationException("Not a delegate.");

        MethodInfo^ invoke = d->GetMethod("Invoke");
        if (invoke == nullptr)
            throw gcnew ApplicationException("Not a delegate.");

        return invoke->ReturnType;
    }
};

int main()
{
    Example::Main();
}

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Windows.Forms;

class ExampleForm : Form
{
    public ExampleForm() : base()
    {
        this.Text = "Click me";
    }
}

class Example
{
    public static void Main()
    {
        Example ex = new Example();
        ex.HookUpDelegate();
    }

    private void HookUpDelegate()
    {
        // Load an assembly, for example using the Assembly.Load
        // method. In this case, the executing assembly is loaded, to
        // keep the demonstration simple.
        //
        Assembly assem = typeof(Example).Assembly;

        // Get the type that is to be loaded, and create an instance
        // of it. Activator.CreateInstance has other overloads, if
        // the type lacks a default constructor. The new instance
        // is stored as type Object, to maintain the fiction that
        // nothing is known about the assembly. (Note that you can
        // get the types in an assembly without knowing their names
        // in advance.)
        //
        Type tExForm = assem.GetType("ExampleForm");
        Object exFormAsObj = Activator.CreateInstance(tExForm);

        // Get an EventInfo representing the Click event, and get the
        // type of delegate that handles the event.
        //
        EventInfo evClick = tExForm.GetEvent("Click");
        Type tDelegate = evClick.EventHandlerType;

        // If you already have a method with the correct signature,
        // you can simply get a MethodInfo for it.
        //
        MethodInfo miHandler =
            typeof(Example).GetMethod("LuckyHandler",
                BindingFlags.NonPublic | BindingFlags.Instance);
            
        // Create an instance of the delegate. Using the overloads
        // of CreateDelegate that take MethodInfo is recommended.
        //
        Delegate d = Delegate.CreateDelegate(tDelegate, this, miHandler);

        // Get the "add" accessor of the event and invoke it late-
        // bound, passing in the delegate instance. This is equivalent
        // to using the += operator in C#, or AddHandler in Visual
        // Basic. The instance on which the "add" accessor is invoked
        // is the form; the arguments must be passed as an array.
        //
        MethodInfo addHandler = evClick.GetAddMethod();
        Object[] addHandlerArgs = { d };
        addHandler.Invoke(exFormAsObj, addHandlerArgs);

        // Event handler methods can also be generated at run time,
        // using lightweight dynamic methods and Reflection.Emit.
        // To construct an event handler, you need the return type
        // and parameter types of the delegate. These can be obtained
        // by examining the delegate's Invoke method.
        //
        // It is not necessary to name dynamic methods, so the empty
        // string can be used. The last argument associates the
        // dynamic method with the current type, giving the delegate
        // access to all the public and private members of Example,
        // as if it were an instance method.
        //
        Type returnType = GetDelegateReturnType(tDelegate);
        if (returnType != typeof(void))
            throw new ArgumentException("Delegate has a return type.", nameof(d));

        DynamicMethod handler =
            new DynamicMethod("",
                              null,
                              GetDelegateParameterTypes(tDelegate),
                              typeof(Example));

        // Generate a method body. This method loads a string, calls
        // the Show method overload that takes a string, pops the
        // return value off the stack (because the handler has no
        // return type), and returns.
        //
        ILGenerator ilgen = handler.GetILGenerator();

        Type[] showParameters = { typeof(String) };
        MethodInfo simpleShow =
            typeof(MessageBox).GetMethod("Show", showParameters);

        ilgen.Emit(OpCodes.Ldstr,
            "This event handler was constructed at run time.");
        ilgen.Emit(OpCodes.Call, simpleShow);
        ilgen.Emit(OpCodes.Pop);
        ilgen.Emit(OpCodes.Ret);

        // Complete the dynamic method by calling its CreateDelegate
        // method. Use the "add" accessor to add the delegate to
        // the invocation list for the event.
        //
        Delegate dEmitted = handler.CreateDelegate(tDelegate);
        addHandler.Invoke(exFormAsObj, new Object[] { dEmitted });

        // Show the form. Clicking on the form causes the two
        // delegates to be invoked.
        //
        Application.Run((Form) exFormAsObj);
    }

    private void LuckyHandler(Object sender, EventArgs e)
    {
        MessageBox.Show("This event handler just happened to be lying around.");
    }

    private Type[] GetDelegateParameterTypes(Type d)
    {
        if (d.BaseType != typeof(MulticastDelegate))
            throw new ArgumentException("Not a delegate.", nameof(d));

        MethodInfo invoke = d.GetMethod("Invoke");
        if (invoke == null)
            throw new ArgumentException("Not a delegate.", nameof(d));

        ParameterInfo[] parameters = invoke.GetParameters();
        Type[] typeParameters = new Type[parameters.Length];
        for (int i = 0; i < parameters.Length; i++)
        {
            typeParameters[i] = parameters[i].ParameterType;
        }
        return typeParameters;
    }

    private Type GetDelegateReturnType(Type d)
    {
        if (d.BaseType != typeof(MulticastDelegate))
            throw new ArgumentException("Not a delegate.", nameof(d));

        MethodInfo invoke = d.GetMethod("Invoke");
        if (invoke == null)
            throw new ArgumentException("Not a delegate.", nameof(d));

        return invoke.ReturnType;
    }
}

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Windows.Forms

Class ExampleForm
    Inherits Form

    Public Sub New()
        Me.Text = "Click me"

    End Sub
End Class

Class Example
    Public Shared Sub Main()
        Dim ex As New Example()
        ex.HookUpDelegate()
    End Sub

    Private Sub HookUpDelegate()
        ' Load an assembly, for example using the Assembly.Load
        ' method. In this case, the executing assembly is loaded, to
        ' keep the demonstration simple.
        '
        Dim assem As Assembly = GetType(Example).Assembly

        ' Get the type that is to be loaded, and create an instance 
        ' of it. Activator.CreateInstance also has an overload that
        ' takes an array of types representing the types of the 
        ' constructor parameters, if the type you are creating does
        ' not have a parameterless constructor. The new instance
        ' is stored as type Object, to maintain the fiction that 
        ' nothing is known about the assembly. (Note that you can
        ' get the types in an assembly without knowing their names
        ' in advance.)
        '
        Dim tExForm As Type = assem.GetType("ExampleForm")
        Dim exFormAsObj As Object = _
            Activator.CreateInstance(tExForm)

        ' Get an EventInfo representing the Click event, and get the
        ' type of delegate that handles the event.
        '
        Dim evClick As EventInfo = tExForm.GetEvent("Click")
        Dim tDelegate As Type = evClick.EventHandlerType

        ' If you already have a method with the correct signature,
        ' you can simply get a MethodInfo for it. 
        '
        Dim miHandler As MethodInfo = _
            GetType(Example).GetMethod("LuckyHandler", _
                BindingFlags.NonPublic Or BindingFlags.Instance)
        ' Create an instance of the delegate. Using the overloads
        ' of CreateDelegate that take MethodInfo is recommended.
        '
        Dim d As [Delegate] = _
            [Delegate].CreateDelegate(tDelegate, Me, miHandler)

        ' Get the "add" accessor of the event and invoke it late-
        ' bound, passing in the delegate instance. This is equivalent
        ' to using the += operator in C#, or AddHandler in Visual
        ' Basic. The instance on which the "add" accessor is invoked
        ' is the form; the arguments must be passed as an array.
        '
        Dim miAddHandler As MethodInfo = evClick.GetAddMethod()
        Dim addHandlerArgs() As Object = {d}
        miAddHandler.Invoke(exFormAsObj, addHandlerArgs)

        ' Event handler methods can also be generated at run time,
        ' using lightweight dynamic methods and Reflection.Emit. 
        ' To construct an event handler, you need the return type
        ' and parameter types of the delegate. These can be obtained
        ' by examining the delegate's Invoke method. 
        '
        ' It is not necessary to name dynamic methods, so the empty 
        ' string can be used. The last argument associates the 
        ' dynamic method with the current type, giving the delegate
        ' access to all the public and private members of Example,
        ' as if it were an instance method.
        '
        Dim returnType As Type = GetDelegateReturnType(tDelegate)
        If returnType IsNot GetType(Void) Then
            Throw New ArgumentException("Delegate has a return type.", NameOf(d))
        End If

        Dim handler As New DynamicMethod( _
            "", _
            Nothing, _
            GetDelegateParameterTypes(tDelegate), _
            GetType(Example) _
        )

        ' Generate a method body. This method loads a string, calls 
        ' the Show method overload that takes a string, pops the 
        ' return value off the stack (because the handler has no
        ' return type), and returns.
        '
        Dim ilgen As ILGenerator = handler.GetILGenerator()

        Dim showParameters As Type() = {GetType(String)}
        Dim simpleShow As MethodInfo = _
            GetType(MessageBox).GetMethod("Show", showParameters)

        ilgen.Emit(OpCodes.Ldstr, _
            "This event handler was constructed at run time.")
        ilgen.Emit(OpCodes.Call, simpleShow)
        ilgen.Emit(OpCodes.Pop)
        ilgen.Emit(OpCodes.Ret)

        ' Complete the dynamic method by calling its CreateDelegate
        ' method. Use the "add" accessor to add the delegate to
        ' the invocation list for the event.
        '
        Dim dEmitted As [Delegate] = handler.CreateDelegate(tDelegate)
        miAddHandler.Invoke(exFormAsObj, New Object() {dEmitted})

        ' Show the form. Clicking on the form causes the two
        ' delegates to be invoked.
        '
        Application.Run(CType(exFormAsObj, Form))

    End Sub

    Private Sub LuckyHandler(ByVal sender As [Object], _
        ByVal e As EventArgs)

        MessageBox.Show("This event handler just happened to be lying around.")
    End Sub

    Private Function GetDelegateParameterTypes(ByVal d As Type) _
        As Type()

        If d.BaseType IsNot GetType(MulticastDelegate) Then
            Throw New ArgumentException("Not a delegate.", NameOf(d))
        End If

        Dim invoke As MethodInfo = d.GetMethod("Invoke")
        If invoke Is Nothing Then
            Throw New ArgumentException("Not a delegate.", NameOf(d))
        End If

        Dim parameters As ParameterInfo() = invoke.GetParameters()
        ' Dimension this array Length - 1, because VB adds an extra
        ' element to zero-based arrays.
        Dim typeParameters(parameters.Length - 1) As Type
        For i As Integer = 0 To parameters.Length - 1
            typeParameters(i) = parameters(i).ParameterType
        Next i

        Return typeParameters

    End Function


    Private Function GetDelegateReturnType(ByVal d As Type) As Type

        If d.BaseType IsNot GetType(MulticastDelegate) Then
            Throw New ArgumentException("Not a delegate.", NameOf(d))
        End If

        Dim invoke As MethodInfo = d.GetMethod("Invoke")
        If invoke Is Nothing Then
            Throw New ArgumentException("Not a delegate.", NameOf(d))
        End If

        Return invoke.ReturnType

    End Function
End Class

Bagikan melalui

Cara: Menghubungkan delegasi menggunakan refleksi

Untuk menghubungkan delegasi menggunakan refleksi

Membuat penanganan aktivitas pada waktu proses dengan menggunakan metode dinamis

Contoh

Lihat juga

Sumber Daya Tambahan: