Como fazer a criação do objeto dinâmico e invocação de método em .NET 3.5

Question

Como é que os olhares de código que iria criar um objeto da classe:

string myClass = "MyClass";

do tipo acima, e depois chamar

string myMethod = "MyMethod";

Por esse objeto?

Answer 1

• Type.GetType(string) para obter o objeto tipo.
• Activator.CreateInstance(Type) para criar uma instância.
• Type.GetMethod(string) para recuperar um método.
• MethodBase.Invoke(object, object[]) para invocar o método no objeto

Exemplo, mas sem a verificação de erros:

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 etapa precisa de uma verificação cuidadosa -. Você não pode encontrar o tipo, ele pode não ter um construtor sem parâmetros, você não pode encontrar o método, você pode invocá-lo com os tipos de argumento errado

Uma coisa a nota:. Type.GetType (string) precisa o nome do assembly qualificado do tipo a menos que seja na execução atualmente montagem ou mscorlib

Answer 2

Eu criei uma biblioteca que simplifica a criação de objetos dinâmica e invocação usando .NET você pode baixar a biblioteca e o código no Google Code: ligação tardia Helper No projeto você vai encontrar um href="http://code.google.com/p/latebindinghelper/wiki/Usage" rel="nofollow noreferrer"> Wiki página , ou você pode também verificar este artigo em CodeProject

Usando minha biblioteca, seu exemplo será parecido com este:

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

Ou ainda mais curto:

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

Ele usa uma interface fluente, e realmente simplifica este tipo de operações. Eu espero que você pode encontrá-lo útil.

Answer 3

O seguinte assume um objeto com um construtor público e um método público que retorna algum valor, mas não tem parâmetros.

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

Answer 4

Assumindo que sua classe está na sua execução montagem, seu construtor e seu método é sem 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 */