Procédure : charger des assemblys dans un domaine d’application
Remarque
Cet article est spécifique au .NET Framework. Elle n’est pas applicable aux implémentations plus récentes de .NET, notamment .NET 6 et les versions ultérieures.
Il existe plusieurs façons de charger un assembly dans un domaine d’application. La procédure recommandée consiste à utiliser la méthode static (Shared en Visual Basic) Load de la classe System.Reflection.Assembly. Vous pouvez aussi adopter les approches suivantes :
La méthode LoadFrom de la classe Assembly charge un assembly en fonction de son emplacement de fichier. Le chargement des assemblys 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 uniquement. Les assemblys chargés dans ce contexte peuvent être examinés mais pas exécutés, ce qui permet d’examiner des assemblys qui ciblent d’autres plateformes. Voir Guide pratique pour charger des assemblys dans le contexte de réflexion uniquement.
Notes
Le contexte de réflexion uniquement est une nouveauté de .NET Framework version 2.0.
Les méthodes telles que CreateInstance et CreateInstanceAndUnwrap de la classe AppDomain peuvent charger des assemblys dans un domaine d’application.
La méthode GetType de la classe Type peut charger des assemblys.
La méthode Load de la classe System.AppDomain peut charger des assemblys, mais est utilisée principalement pour l’interopérabilité COM. Vous ne devez pas l’utiliser pour charger des assemblys dans un domaine d’application autre que celui à partir duquel elle est appelée.
Notes
Depuis .NET Framework version 2.0, le runtime ne charge pas un assembly qui a été compilé avec une version de .NET Framework dont le numéro de version est supérieur au runtime chargé actuellement. Cela s’applique à la combinaison des composants majeurs et mineurs du numéro de version.
Vous pouvez spécifier la façon dont le code compilé juste-à-temps (JIT) des assemblys chargés est partagé entre les domaines d’application. Pour plus d’informations, consultez Domaines d’application et assemblys.
Exemple
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 obtenir une description complète de l’obtention d’informations à partir d’un assembly chargé, consultez Chargement et utilisation dynamiques des 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
