Reflektion: Wie Methode mit Parametern aufgerufen wird

Ich versuche eine Methode aufzurufen, die Sie über reflektion mit Parametern und ich bekomme:

Objekt nicht mit Zieltyp

Wenn ich das aufrufen einer Methode ohne Parameter funktioniert es einwandfrei. Basierend auf den folgenden code, wenn ich die Methode aufrufen Test("TestNoParameters") es funktioniert gut. Jedoch wenn ich den Anruf Test("Run") ich eine Ausnahme. Ist etwas falsch mit meinem code?

Meine anfängliche Zweck war die übergabe eines Arrays von Objekten z.B. public void Run(object[] options) aber das hat nicht funktioniert und ich habe versucht etwas einfacher, z.B. string, ohne Erfolg.

//Assembly1.dll
namespace TestAssembly
{
    public class Main
    {
        public void Run(string parameters)
        { 
            //Do something... 
        }
        public void TestNoParameters()
        {
            //Do something... 
        }
    }
}

//Executing Assembly.exe
public class TestReflection
{
    public void Test(string methodName)
    {
        Assembly assembly = Assembly.LoadFile("...Assembly1.dll");
        Type type = assembly.GetType("TestAssembly.Main");

        if (type != null)
        {
            MethodInfo methodInfo = type.GetMethod(methodName);

            if (methodInfo != null)
            {
                object result = null;
                ParameterInfo[] parameters = methodInfo.GetParameters();
                object classInstance = Activator.CreateInstance(type, null);

                if (parameters.Length == 0)
                {
                    //This works fine
                    result = methodInfo.Invoke(classInstance, null);
                }
                else
                {
                    object[] parametersArray = new object[] { "Hello" };

                    //The invoke does NOT work;
                    //it throws "Object does not match target type"             
                    result = methodInfo.Invoke(methodInfo, parametersArray);
                }
            }
        }
    }
}
Kommentare dem Thema
die korrekte Zeile wäre, object[] parametersArray = new object[] { new object[] { "Hallo" } }; Kommentarautor: Nick Kovalsky

InformationsquelleAutor der Frage Ioannis | 2010-02-04

  1. 192

    Ändern "methodInfo" zu "classInstance", wie im Aufruf mit dem parameter null array.

      result = methodInfo.Invoke(classInstance, parametersArray);

    InformationsquelleAutor der Antwort womp

  2. 24

    Haben Sie einen Fehler genau dort

    result = methodInfo.Invoke(methodInfo, parametersArray);

    sollte es

    result = methodInfo.Invoke(classInstance, parametersArray);

    InformationsquelleAutor der Antwort Oleg I.

  3. 19

    Ein grundlegender Fehler ist hier:

    result = methodInfo.Invoke(methodInfo, parametersArray);

    Werden Sie den Aufruf der Methode auf eine Instanz der MethodInfo. Sie müssen pass, die in einer Instanz des Typs der Objekte, die Sie aufrufen möchten, auf. 

    result = methodInfo.Invoke(classInstance, parametersArray);

    InformationsquelleAutor der Antwort jason

  4. 8

    Die bereitgestellte Lösung funktioniert nicht für Instanzen von Typen geladen von einem remote-Montage. Um das zu tun, hier ist eine Lösung, die funktioniert in allen Situationen, die mit einer expliziten Typ re-mapping des Typs zurückgegeben durch die CreateInstance-Aufruf.

    Dies ist, wie ich brauche, um meine classInstance, wie es sich in einem remote-Montage.

    //sample of my CreateInstance call with an explicit assembly reference
object classInstance = Activator.CreateInstance(assemblyName, type.FullName);

    Allerdings auch mit der Antwort oben würde Sie immer noch die gleichen Fehler. Hier ist, wie das geht:

    //first, create a handle instead of the actual object
ObjectHandle classInstanceHandle = Activator.CreateInstance(assemblyName, type.FullName);
//unwrap the real slim-shady
object classInstance = classInstanceHandle.Unwrap(); 
//re-map the type to that of the object we retrieved
type = classInstace.GetType();

    Dann machen Sie es wie die anderen Benutzer hier erwähnt.

    InformationsquelleAutor der Antwort Martin Kool

  5. 3

    Ich würde es so zu benutzen, seinen Weg kürzer und wird es nicht geben keine Probleme

            dynamic result = null;
        if (methodInfo != null)
        {
            ParameterInfo[] parameters = methodInfo.GetParameters();
            object classInstance = Activator.CreateInstance(type, null);
            result = methodInfo.Invoke(classInstance, parameters.Length == 0 ? null : parametersArray);
        }

    InformationsquelleAutor der Antwort Nick N.

  6. 0
     Assembly assembly = Assembly.LoadFile(@"....bin\Debug\TestCases.dll");
       //get all types
        var testTypes = from t in assembly.GetTypes()
                        let attributes = t.GetCustomAttributes(typeof(NUnit.Framework.TestFixtureAttribute), true)
                        where attributes != null && attributes.Length > 0
                        orderby t.Name
                        select t;

        foreach (var type in testTypes)
        {
            //get test method in types.
            var testMethods = from m in type.GetMethods()
                              let attributes = m.GetCustomAttributes(typeof(NUnit.Framework.TestAttribute), true)
                              where attributes != null && attributes.Length > 0
                              orderby m.Name
                              select m;

            foreach (var method in testMethods)
            {
                MethodInfo methodInfo = type.GetMethod(method.Name);

                if (methodInfo != null)
                {
                    object result = null;
                    ParameterInfo[] parameters = methodInfo.GetParameters();
                    object classInstance = Activator.CreateInstance(type, null);

                    if (parameters.Length == 0)
                    {
                        //This works fine
                        result = methodInfo.Invoke(classInstance, null);
                    }
                    else
                    {
                        object[] parametersArray = new object[] { "Hello" };

                        //The invoke does NOT work;
                        //it throws "Object does not match target type"             
                        result = methodInfo.Invoke(classInstance, parametersArray);
                    }
                }

            }
        }

    InformationsquelleAutor der Antwort M Fatih Koca

  7. 0

    Ich versucht alle vorgeschlagenen Antworten oben, aber nichts scheint zu funktionieren für mich. Also ich versuche zu erklären, was für mich gearbeitet hier.

    Ich glaube, wenn Sie den Aufruf einer bestimmten Methode wie die Main unten oder auch mit einem einzelnen parameter, wie in Ihrer Frage, die Sie gerade haben, ändern Sie den Parametertyp aus string zu object für diese Arbeit

    class Class1
{
    public static void Execute(object[] str)
    {...}
}

    Dann müssen Sie das parameterArray in einem Objekt-array wie unten, während die Berufung auf Sie.

    MethodInfo mi = typeInstance.GetType().GetMethod("Execute");
ParameterInfo[] parameters = mi.GetParameters();
object classInstance = Activator.CreateInstance(typeInstance.GetType(), null);

if (parameters.Length == 0)
{
    //This works fine
    var result = mi.Invoke(classInstance, null);
}
else
{
    object[] parametersArray = new object[] { "Hello","bye" };
    var result = mi.Invoke(classInstance,new object[] { parametersArray } );
}

    Hoffe, das hilft

    InformationsquelleAutor der Antwort Vinod Srivastav

Schreibe einen Kommentar