Cómo hacer la creación dinámica de objetos y la invocación de métodos en .NET 3.5

Question

Cómo se ve el código que crearía un objeto de clase:

string myClass = "MyClass";

Del tipo anterior, y luego llame

string myMethod = "MyMethod";

¿Sobre ese objeto?

Answer 1

• Use Type.GetType(string) para obtener el tipo objeto.
• Utilice Activator.CreateInstance(Type) para crear una instancia .
• Use Type.GetMethod(string) para recuperar un método .
• Utilice MethodBase.Invoke(object, object[]) para invocar el método en el objeto

Ejemplo, pero sin verificación de errores:

using System;
using System.Reflection;

namespace Foo
{
    class Test
    {
        static void Main()
        {
            Type type = Type.GetType("Foo.MyClass");
            object instance = Activator.CreateInstance(type);
            MethodInfo method = type.GetMethod("MyMethod");
            method.Invoke(instance, null);
        }
    }

    class MyClass
    {
        public void MyMethod()
        {
            Console.WriteLine("In MyClass.MyMethod");
        }
    }
}

Cada paso necesita una comprobación cuidadosa: es posible que no encuentre el tipo, que no tenga un constructor sin parámetros, que no encuentre el método, que pueda invocarlo con los tipos de argumento incorrectos.

Una cosa a tener en cuenta: Type.GetType (string) necesita el nombre calificado del ensamblado del tipo a menos que esté en el ensamblaje que se está ejecutando actualmente o mscorlib.

Answer 2

He creado una biblioteca que simplifica la creación y la invocación de objetos dinámicos usando .NET. Puede descargar la biblioteca y el código en el código de google: Ayudante de enlace tardío En el proyecto encontrará una página Wiki con el uso , o puede también consulte este artículo en CodeProject

Usando mi biblioteca, su ejemplo se verá así:

IOperationInvoker myClass = BindingFactory.CreateObjectBinding("MyClassAssembly", "MyClass");
myClass.Method("MyMethod").Invoke();

O incluso más corto:

BindingFactory.CreateObjectBinding("MyClassAssembly", "MyClass")
     .Method("MyMethod")
     .Invoke();

Utiliza una interfaz fluida y realmente simplifica este tipo de operaciones. Espero que te sea útil.

Answer 3

Lo siguiente asume un objeto con un constructor público y un método público que devuelve algún valor pero no toma parámetros.

var object = Activator.CreateInstance( "MyClass" );
var result = object.GetType().GetMethod( "MyMethod" ).Invoke( object, null );

Answer 4

Suponiendo que su clase está en su ensamblaje en ejecución, su constructor y su método no tienen parámetros.

Type clazz = System.Reflection.Assembly.GetExecutingAssembly().GetType("MyClass");

System.Reflection.ConstructorInfo ci = clazz.GetConstructor(new Type[] { });
object instance = ci.Invoke(null); /* Send parameters instead of null here */

System.Reflection.MethodInfo mi = clazz.GetMethod("MyMethod");
mi.Invoke(instance, null); /* Send parameters instead of null here */