Guide pratique pour charger des assemblys dans un domaine d’application

Il existe plusieurs façons de charger un assembly dans un domaine d’application. La méthode recommandée consiste à utiliser la static méthode (Shared en Visual Basic) Load de la System.Reflection.Assembly classe. Voici d’autres façons de charger des assemblages :

• La LoadFrom méthode de la Assembly classe charge un assembly en fonction de son emplacement de fichier. Le chargement d'assemblages avec cette méthode utilise un contexte de chargement différent.

• Les méthodes ReflectionOnlyLoad et ReflectionOnlyLoadFrom chargent un assembly dans le contexte de réflexion seulement. Les assemblies chargées dans ce contexte peuvent être examinées, mais pas exécutées, permettant l'examen des assemblies qui ciblent d'autres plateformes. Découvrez comment charger des assembly dans le contexte Reflection-Only.

• Les méthodes telles que CreateInstance et CreateInstanceAndUnwrap de la AppDomain classe peuvent charger des assemblys dans un domaine d’application.

• La méthode GetType de la classe Type peut charger des assemblies.

• La Load méthode de la System.AppDomain classe peut charger des assemblys, mais est principalement utilisée pour l’interopérabilité COM. Il ne doit pas être utilisé pour charger des assemblys dans un domaine d’application autre que le domaine d’application à partir duquel il est appelé.

Vous pouvez spécifier comment le code compilé juste-à-temps (JIT) à partir des assemblages chargés est partagé entre les domaines d'application. Pour plus d’informations, consultez Domaines et assemblys d’application.

Example

Le code suivant charge un assembly nommé «example.exe» ou «example.dll» dans le domaine d’application actuel, obtient un type nommé Example à partir de l’assembly, obtient une méthode sans paramètre nommée MethodA pour ce type et exécute la méthode. Pour une discussion complète sur l’obtention d’informations à partir d’un assembly chargé, consultez Chargement dynamique et utilisation de types.

using namespace System;
using namespace System::Reflection;

public ref class Asmload0
{
public:
    static void Main()
    {
        // Use the file name to load the assembly into the current
        // application domain.
        Assembly^ a = Assembly::Load("example");
        // Get the type to use.
        Type^ myType = a->GetType("Example");
        // Get the method to call.
        MethodInfo^ myMethod = myType->GetMethod("MethodA");
        // Create an instance.
        Object^ obj = Activator::CreateInstance(myType);
        // Execute the method.
        myMethod->Invoke(obj, nullptr);
    }
};

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

using System;
using System.Reflection;

public class Asmload0
{
    public static void Main()
    {
        // Use the file name to load the assembly into the current
        // application domain.
        Assembly a = Assembly.Load("example");
        // Get the type to use.
        Type myType = a.GetType("Example");
        // Get the method to call.
        MethodInfo myMethod = myType.GetMethod("MethodA");
        // Create an instance.
        object obj = Activator.CreateInstance(myType);
        // Execute the method.
        myMethod.Invoke(obj, null);
    }
}

Imports System.Reflection

Public Class Asmload0
    Public Shared Sub Main()
        ' Use the file name to load the assembly into the current
        ' application domain.
        Dim a As Assembly = Assembly.Load("example")
        ' Get the type to use.
        Dim myType As Type = a.GetType("Example")
        ' Get the method to call.
        Dim myMethod As MethodInfo = myType.GetMethod("MethodA")
        ' Create an instance.
        Dim obj As Object = Activator.CreateInstance(myType)
        ' Execute the method.
        myMethod.Invoke(obj, Nothing)
    End Sub
End Class

Voir aussi

• ReflectionOnlyLoad
• Programmation avec des domaines d’application
• Réflexion
• Utilisation de domaines d’application
• Comment charger des assemblies dans le contexte Reflection-Only
• Domaines et assemblys d’application