ModuleResolveEventHandler Delegato

Definizione

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 

Parametri

Valore restituito

Il modulo che soddisfa la richiesta.

Attributi

SerializableAttribute ComVisibleAttribute

Esempio

Nell'esempio seguente viene illustrata la sequenza di esecuzione in cui viene chiamato un gestore eventi. In questo esempio Server1 è un modulo esterno della 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;
    }
}

Per compilare ed eseguire l'esempio:

1. Compilare Server1 usando il comando seguente:

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

2. Compilare MySample usando il comando seguente:

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

3. Eseguire MySample.exe.

Commenti

Se il caricatore della classe Common Language Runtime non è in grado di risolvere un riferimento a un modulo interno di un assembly tramite mezzi normali, questo evento viene generato. Il gestore eventi per questo delegato deve individuare e restituire un modulo che soddisfa la richiesta.

Metodi di estensione

Si applica a