Sdílet prostřednictvím


ModuleResolveEventHandler Delegát

Definice

Představuje metodu, která bude zpracovávat ModuleResolve událost objektu Assembly.

public delegate System::Reflection::Module ^ ModuleResolveEventHandler(System::Object ^ sender, ResolveEventArgs ^ e);
public delegate System.Reflection.Module ModuleResolveEventHandler(object sender, ResolveEventArgs e);
[System.Serializable]
public delegate System.Reflection.Module ModuleResolveEventHandler(object sender, ResolveEventArgs e);
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public delegate System.Reflection.Module ModuleResolveEventHandler(object sender, ResolveEventArgs e);
type ModuleResolveEventHandler = delegate of obj * ResolveEventArgs -> Module
[<System.Serializable>]
type ModuleResolveEventHandler = delegate of obj * ResolveEventArgs -> Module
[<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 

Parametry

sender
Object

Sestavení, které bylo zdrojem události.

e
ResolveEventArgs

Argumenty zadané objektem popisujícím událost.

Návratová hodnota

Modul, který vyhovuje požadavku.

Atributy

Příklady

Následující příklad ukazuje posloupnost spuštění, ve které je volána obslužná rutina události. V tomto příkladu je Server1 externím modulem třídy 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;
    }
}

Kompilace a spuštění příkladu:

  1. Zkompilujte Server1 pomocí následujícího příkazu:

    csc /out:subfolder\Server1.netmodule /t:module Server1.cs
    
  2. Zkompilujte MySample pomocí následujícího příkazu:

    csc /out:MySample.exe /t:exe /addmodule:subfolder\Server1.netmodule MySample.cs
    
  3. Spusťte MySample.exe.

Poznámka

Soubor modulu Server1.netmodule musí být v podadresáři s názvem "podsložka", aby tento příklad fungoval správně.

Poznámky

Pokud zavaděč třídy CLR (Common Language Runtime) nemůže přeložit odkaz na interní modul sestavení normálními prostředky, je vyvolána tato událost. Obslužná rutina události pro tohoto delegáta musí vyhledat a vrátit modul, který splňuje požadavek.

Metody rozšíření

GetMethodInfo(Delegate)

Získá objekt, který představuje metodu reprezentovanou zadaným delegátem.

Platí pro