ModuleResolveEventHandler Délégué

Définition

Espace de noms:

System.Reflection

Assembly:

mscorlib.dll

Représente la méthode qui gère l’événement ModuleResolve d’un Assembly.

public delegate System::Reflection::Module ^ ModuleResolveEventHandler(System::Object ^ sender, ResolveEventArgs ^ e);

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public delegate System.Reflection.Module ModuleResolveEventHandler(object sender, ResolveEventArgs e);

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ModuleResolveEventHandler = delegate of obj * ResolveEventArgs -> Module

Public Delegate Function ModuleResolveEventHandler(sender As Object, e As ResolveEventArgs) As Module 

Paramètres

sender

Object

Assembly qui était la source de l’événement.

e

ResolveEventArgs

Arguments fournis par l’objet décrivant l’événement.

Valeur renvoyée

Module

Module qui répond à la demande.

Attributs

SerializableAttribute ComVisibleAttribute

Exemples

L’exemple suivant illustre la séquence d’exécution dans laquelle un gestionnaire d’événements est appelé. Dans cet exemple, Server1 est un module externe de la classe MySample.

using System;
using System.IO;
using System.Reflection;

class MySample
{
    public static int Main(String[] args)
    {
        Assembly asm1 = typeof(MySample).Assembly;
        asm1.ModuleResolve += new ModuleResolveEventHandler(evModuleResolve);
        Console.WriteLine("Calling MySample.Test...");
        Test();
        return 0;
    }
    private static Module evModuleResolve(object sender, ResolveEventArgs e)
    {
        Console.WriteLine();
        Console.WriteLine("******************************************************");
        Console.WriteLine("* MySample.evModuleResolve() in module: {0:s} *",
            Type.GetType("MySample").Module.ScopeName);
        Console.WriteLine("******************************************************");
        FileStream fs = File.Open("subfolder\\Server1.netmodule", FileMode.Open);
        long len = fs.Length;
        byte[] rgFileBytes = new byte[len];
        fs.Read(rgFileBytes, 0, (int)len);
        Assembly a = typeof(MySample).Assembly;
        Module m = a.LoadModule("Server1.netmodule", rgFileBytes);
        return m;
    }
    private static void Test()
    {
        Console.WriteLine("Instantiating Server1...");
        Server1 s = new Server1();
        Console.WriteLine("Calling Server1.trivial...");
        s.trivial();
    }
}

// Server1 module

using System;
using System.Reflection;

public class Server1 : MarshalByRefObject
{
    public int trivial()
    {
        Console.WriteLine();
        Console.WriteLine("******************************************************");
        Console.WriteLine("*   Server1.trivial() in module: {0:s}   *", this.GetType().Module.ScopeName);
        Console.WriteLine("******************************************************");
        Console.WriteLine("Returning from Server1.trivial...");
        return 1;
    }
}

Pour compiler et exécuter l’exemple :

1. Compilez Server1 à l’aide de la commande suivante :

   csc /out:subfolder\Server1.netmodule /t:module Server1.cs
   

2. Compilez MySample à l’aide de la commande suivante :

   csc /out:MySample.exe /t:exe /addmodule:subfolder\Server1.netmodule MySample.cs
   

3. Exécutez MySample.exe.

Note

Le fichier de module Server1.netmodule doit se trouver dans un sous-répertoire nommé « sous-dossier » pour que cet exemple fonctionne correctement.

Remarques

Si le chargeur de classes Common Language Runtime ne peut pas résoudre une référence à un module interne d’un assembly par le biais de moyens normaux, cet événement est déclenché. Le gestionnaire d’événements de ce délégué doit localiser et retourner un module répondant à la demande.

Méthodes d’extension

Nom	Description
GetMethodInfo(Delegate)	Obtient un objet qui représente la méthode représentée par le délégué spécifié.