c# - read - Cómo hacer creación dinámica de objetos e invocación de métodos en.NET 3.5

static dynamic c#

Question

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

string myClass = "MyClass";

Del tipo anterior, y luego llamar

string myMethod = "MyMethod";

En ese objeto?

Answer 1

Creé una biblioteca que simplifica la creación de objetos dinámicos y la invocación con .NET. Puede descargar la biblioteca y el código en el código de google: Auxiliar de enlace tardío En el proyecto, encontrará una página Wiki con el uso , o también puede verificar esto. 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 puedas encontrarlo útil.

Answer 2

Lo siguiente supone un objeto con un constructor público y un método público que devuelve cierto valor pero no toma ningún parámetro.

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

Answer 3

Suponiendo que su clase está en su ensamblado de 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 */

Answer 4

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

Ejemplo, pero sin comprobació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, puede invocarlo con tipos de argumentos incorrectos.

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