Comment créer des objets dynamiques et invoquer des méthodes dans .NET 3.5

Question

À quoi ressemble le code qui créerait un objet de classe:

string myClass = "MyClass";

Du type ci-dessus, puis appelez

string myMethod = "MyMethod";

Sur cet objet?

Answer 1

• Utilisez Type.GetType(string) pour obtenir le type objet.
• Utilisez Activator.CreateInstance(Type) pour créer une instance .
• Utilisez Type.GetMethod(string) pour récupérer une méthode .
• Utilisez MethodBase.Invoke(object, object[]) pour appeler la méthode sur l'objet

Exemple, mais sans vérification d'erreur:

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");
        }
    }
}

Chaque étape nécessite un contrôle minutieux - vous pouvez ne pas trouver le type, il peut ne pas avoir de constructeur sans paramètre, vous ne pouvez pas trouver la méthode, vous pouvez l'invoquer avec les mauvais types d'arguments.

Une chose à noter: Type.GetType (chaîne) a besoin du nom qualifié du type d'assembly, sauf s'il se trouve dans l'assembly ou la mscorlib en cours d'exécution.

Answer 2

J'ai créé une bibliothèque qui simplifie la création et l'invocation d'objets dynamiques à l'aide de .NET. Vous pouvez télécharger la bibliothèque et le code dans le code Google: Aide de liaison tardive Dans le projet, vous trouverez une page wiki sur l'utilisation , ou vous pouvez Consultez également cet article de CodeProject

.

En utilisant ma bibliothèque, votre exemple ressemblera à ceci:

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

Ou même plus court:

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

Il utilise une interface fluide et simplifie vraiment ce type d’opérations. J'espère que vous pourrez le trouver utile.

Answer 3

Ce qui suit suppose un objet avec un constructeur public et une méthode publique qui renvoie une valeur mais ne prend aucun paramètre.

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

Answer 4

En supposant que votre classe figure dans votre assemblage d'exécution, votre constructeur et votre méthode sont sans paramètre.

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 */