Cómo: Cargar ensamblados en un dominio de aplicación

Hay varias maneras de cargar un ensamblado en un dominio de aplicación. La manera recomendada es usar el static método (Shared en Visual Basic) Load de la System.Reflection.Assembly clase . Otras formas en que los ensamblados se pueden cargar incluyen:

• El LoadFrom método de la Assembly clase carga un ensamblado según su ubicación de archivo. La carga de ensamblados con este método usa un contexto de carga diferente.

• Los métodos ReflectionOnlyLoad y ReflectionOnlyLoadFrom cargan un ensamblado en el contexto de solo reflexión. Los ensamblados cargados en este contexto se pueden examinar, pero no ejecutar, lo que permite examinar los ensamblados que tienen como destino otras plataformas. Vea Cómo: Cargar ensamblados en el contexto de Reflection-Only.

• Los métodos como CreateInstance y CreateInstanceAndUnwrap de la AppDomain clase pueden cargar ensamblados en un dominio de aplicación.

• El GetType método de la Type clase puede cargar ensamblados.

• El Load método de la System.AppDomain clase puede cargar ensamblados, pero se usa principalmente para la interoperabilidad COM. No se debe usar para cargar ensamblados en un dominio de aplicación distinto del dominio de aplicación desde el que se llama.

Puede especificar la forma en que el código compilado Just-In-Time (JIT) de los ensamblados cargados se comparte entre dominios de aplicación. Para obtener más información, consulte Dominios de aplicación y ensamblados.

Example

El código siguiente carga un ensamblado denominado "example.exe" o "example.dll" en el dominio de aplicación actual, obtiene un tipo denominado Example del ensamblado, obtiene un método sin parámetros denominado MethodA para ese tipo y ejecuta el método . Para obtener una explicación completa sobre cómo obtener información de un ensamblado cargado, consulte Carga dinámica y uso de tipos.

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

Consulte también

• ReflectionOnlyLoad
• Programación con dominios de aplicación
• Reflexión
• Uso de dominios de aplicación
• Cómo: Cargar ensamblados en el contexto de Reflection-Only
• Dominios de aplicación y ensamblados