método de llamada en tiempo de ejecución

Question

Me pregunto si es posible cargar una DLL .NET en tiempo de ejecución, ver los métodos disponibles y ejecutar uno en tiempo de ejecución.

Si esto es posible que se me señale en la dirección correcta

Answer 1

Generalmente, utiliza clases System.Reflection para realizar esta tarea.

En concreto, te carga la DLL a través de Assembly.Load (o Assembly.LoadFrom) y luego llama a Assembly.GetTypes y luego para cada tipo de llamada Type.GetMethods. Cuando tiene un MethodInfo, puede llamar al MethodInfo.Invoke en él.

Answer 2

Es necesario utilizar Reflection.

Puede llamar Assembly.LoadFile para cargar una DLL que contiene un ensamblado de .NET, a continuación, llamar al método GetTypes en el Assembly objeto devuelto a mirar a las clases en el archivo DLL.
Una vez que haya encontrado un objeto Type para la clase que le interesa, puede llamar al método InvokeMember para llamar a una función.

Tenga en cuenta que la reflexión puede ser bastante lenta.

Answer 3

He encontrado esto en reflection eamples

// get all public static methods of MyClass type 
    MethodInfo[] methodInfos = typeof(MyClass).GetMethods(BindingFlags.Public | 
                BindingFlags.Static); 


[C#] 
// dynamically load assembly from file Test.dll 
Assembly testAssembly = Assembly.LoadFile(@"c:\Test.dll"); 

[C#] 
// get type of class Calculator from just loaded assembly 
Type calcType = testAssembly.GetType("Test.Calculator"); 

[C#] 
// create instance of class Calculator 
object calcInstance = Activator.CreateInstance(calcType); 

[C#] 
// get info about property: public double Number 
PropertyInfo numberPropertyInfo = calcType.GetProperty("Number"); 

[C#] 
// get value of property: public double Number 
double value = (double)numberPropertyInfo.GetValue(calcInstance, null); 

[C#] 
// set value of property: public double Number 
numberPropertyInfo.SetValue(calcInstance, 10.0, null); 

[C#] 
// get info about static property: public static double Pi 
PropertyInfo piPropertyInfo = calcType.GetProperty("Pi"); 

[C#] 
// get value of static property: public static double Pi 
double piValue = (double)piPropertyInfo.GetValue(null, null); 

[C#] 
// invoke public instance method: public void Clear() 
calcType.InvokeMember("Clear", 
BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public, 
null, calcInstance, null); 

[C#] 
// invoke private instance method: private void DoClear() 
calcType.InvokeMember("DoClear", 
BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.NonPublic, 
null, calcInstance, null); 

[C#] 
// invoke public instance method: public double Add(double number) 
double value = (double)calcType.InvokeMember("Add", 
BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public, 
null, calcInstance, new object[] { 20.0 }); 

[C#] 
// invoke public static method: public static double GetPi() 
double piValue = (double)calcType.InvokeMember("GetPi", 
BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.Public, 
null, null, null); 

[C#] 
// get value of private field: private double _number 
double value = (double)calcType.InvokeMember("_number", 
BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic, 
null, calcInstance, null); 

Answer 4

Sí, esto es posible, que acaba de empezar con la carga de la DLL:

Assembly assembly = Assembly.LoadFrom(assemblyPath); 

Y a continuación, para invocar un método dentro de su DLL se le tiene que usar reflection.

object obj = assembly.CreateInstance(<type.FullName>); 

donde type.FullName es la propiedad FullName de algún tipo en ese conjunto.

Una vez que tienes tu ejemplo, puede invocar el método como este:

MethodInfo methodInfo = obj.GetMethod("MyMethod"); 
methodInfo.Invoke(obj,null);