Como: Carregar assemblies em um domínio do aplicativo
Observação
Este artigo é específico para aplicativos .NET Framework. Não se aplica a implementações mais recentes do .NET, incluindo o .NET 6 e versões posteriores.
Há várias maneiras de carregar um assembly em um domínio de aplicativo. A maneira recomendada é usar o método Loadstatic (Shared no Visual Basic) da classe System.Reflection.Assembly. Outras maneiras que os assemblies podem ser carregados incluem:
O método LoadFrom da classe Assembly carrega um assembly dado seu local do arquivo. O carregamento de assemblies com esse método usa um contexto de carga diferente.
Os métodos ReflectionOnlyLoad e ReflectionOnlyLoadFrom carregam um assembly no contexto de somente reflexão. Os assemblies carregados neste contexto podem ser examinados, mas não executados, permitindo o exame dos assemblies que visam outras plataformas. Consulte How to: Load Assemblies into the Reflection-Only Context.
Observação
O contexto de somente reflexão é uma novidade no .NET Framework versão 2.0.
Métodos como CreateInstance e CreateInstanceAndUnwrap da classe AppDomain podem carregar assemblies em um domínio de aplicativo.
O método Load da classe System.AppDomain pode carregar assemblies, mas ele é usado principalmente para a interoperabilidade COM. Ele não deve ser usado para carregar assemblies em um domínio do aplicativo diferente do domínio do aplicativo do qual ele foi chamado.
Observação
A partir do .NET Framework versão 2.0, o runtime não carregará um assembly que foi compilado com uma versão do .NET Framework que tenha um número de versão mais alto do que o runtime atualmente carregado. Isso vale para a combinação dos componentes principal e secundário do número de versão.
Você pode especificar a maneira como o JIT (Just-In-Time) compilou o código dos assemblies carregados é compartilhado entre os domínios do aplicativo. Para obter mais informações, confira Domínios do aplicativo e assemblies.
Exemplo
O código a seguir carrega um assembly chamado "example.exe" ou "example.dll" para o domínio de aplicativo atual, obtém um tipo chamado Example do assembly, obtém um método sem parâmetros chamado MethodA para esse tipo e executa o método. Para encontrar uma discussão completa sobre como obter as informações de um assembly carregado, consulte Dynamically Loading and Using Types (Carregando e usando tipos dinamicamente).
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
