प्रतिबिंब: मापदंडों के साथ विधि कैसे लागू करें

Question

मैं मापदंडों के साथ प्रतिबिंब के माध्यम से एक विधि को लागू करने की कोशिश कर रहा हूं और मुझे प्राप्त होता है:

ऑब्जेक्ट लक्ष्य प्रकार से मेल नहीं खाता है

अगर मैं बिना पैरामीटर के किसी विधि को लागू करता हूं, तो यह ठीक काम करता है। निम्नलिखित कोड के आधार पर अगर मैं विधि को कॉल करता हूं Test("TestNoParameters"), तो यह ठीक काम करता है। हालांकि अगर मैं फोन करता हूं Test("Run"), तो मुझे एक अपवाद मिलता है। क्या मेरे कोड में कुछ गड़बड़ है?

मेरा प्रारंभिक उद्देश्य वस्तुओं की एक सरणी को पारित करना था, public void Run(object[] options)लेकिन यह काम नहीं किया और मैंने सफलता के बिना कुछ सरल जैसे स्ट्रिंग की कोशिश की।

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

Comments

सही रेखा वस्तु होगी [] पैरामीटरअरे = नई वस्तु [] {नई वस्तु [] {"हैलो"}};

— निक कोवाल्स्की

Answer 1

"MethodInfo" को "classInstance" में बदलें, ठीक उसी तरह जैसे कॉल में null पैरामीटर ऐरे के साथ होता है।

  result = methodInfo.Invoke(classInstance, parametersArray);

Comments

यह काम करता है, जब एक दूरस्थ विधानसभा की आवृत्ति के साथ काम करने के अलावा। समस्या यह थी कि यह वही त्रुटि फैलाता है जो बहुत उपयोगी नहीं है। मैंने इसे ठीक करने की कोशिश में कई घंटे बिताए, और मेरे मामले और यहां प्रदान किए गए दोनों के लिए एक नया सामान्य समाधान पोस्ट किया। मामले में किसी को भी इसकी आवश्यकता हो सकती है :)

— मार्टिन कूल

यदि पैरामीटर कई प्रकार के हैं, तो सरणी किस तरह होनी चाहिए? वस्तुओं की एक सरणी ??

— राडू

हां, यह एक वस्तु होनी चाहिए [] यदि कई प्रकार के तर्क हैं

— मार्टिन जोहानसन

Answer 2

आपके पास एक बग है

result = methodInfo.Invoke(methodInfo, parametersArray);

यह होना चाहिए

result = methodInfo.Invoke(classInstance, parametersArray);

Answer 3

एक बुनियादी गलती यहाँ है:

result = methodInfo.Invoke(methodInfo, parametersArray); 

आप एक उदाहरण पर विधि लागू कर रहे हैं MethodInfo। आपको उस ऑब्जेक्ट के प्रकार के एक उदाहरण में पास करने की आवश्यकता है, जिस पर आप आह्वान करना चाहते हैं।

result = methodInfo.Invoke(classInstance, parametersArray);

Answer 4

प्रदान किया गया समाधान दूरस्थ विधानसभा से लोड किए गए प्रकारों के उदाहरणों के लिए काम नहीं करता है। ऐसा करने के लिए, यहां एक समाधान है जो सभी स्थितियों में काम करता है, जिसमें CreateInstance कॉल के माध्यम से लौटाए गए प्रकार का एक स्पष्ट प्रकार पुन: मानचित्रण शामिल है।

यह है कि मुझे अपना क्लास इनस्टेंस बनाने की आवश्यकता है, क्योंकि यह एक दूरस्थ विधानसभा में स्थित था।

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

हालाँकि, ऊपर दिए गए उत्तर के साथ भी, आपको अभी भी वही त्रुटि मिलेगी। यहाँ कैसे जाने के बारे में है:

// 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(); 

फिर अन्य उपयोगकर्ताओं के रूप में यहाँ उल्लेख किया है।

Answer 5

मैं इसे इस तरह से उपयोग करूंगा, इसका तरीका छोटा होगा और यह कोई समस्या नहीं देगा

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

Answer 6

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

            }
        }

Answer 7

मैंने उपरोक्त सभी सुझाए गए उत्तरों के साथ काम करने की कोशिश की, लेकिन मेरे लिए कुछ भी काम नहीं आया। इसलिए मैं यह समझाने की कोशिश कर रहा हूं कि मेरे लिए यहां क्या काम हुआ।

मेरा मानना ​​है कि यदि आप Mainनीचे दिए गए तरीके या यहां तक ​​कि अपने प्रश्न के अनुसार एक भी पैरामीटर के साथ कॉल कर रहे हैं , तो आपको इसके लिए काम stringकरने के objectलिए बस इसके प्रकार के पैरामीटर को बदलना होगा । मेरे पास नीचे की तरह एक वर्ग है

//Assembly.dll
namespace TestAssembly{
    public class Main{

        public void Hello()
        { 
            var name = Console.ReadLine();
            Console.WriteLine("Hello() called");
            Console.WriteLine("Hello" + name + " at " + DateTime.Now);
        }

        public void Run(string parameters)
        { 
            Console.WriteLine("Run() called");
            Console.Write("You typed:"  + parameters);
        }

        public string TestNoParameters()
        {
            Console.WriteLine("TestNoParameters() called");
            return ("TestNoParameters() called");
        }

        public void Execute(object[] parameters)
        { 
            Console.WriteLine("Execute() called");
           Console.WriteLine("Number of parameters received: "  + parameters.Length);

           for(int i=0;i<parameters.Length;i++){
               Console.WriteLine(parameters[i]);
           }
        }

    }
}

फिर आपको किसी ऑब्जेक्ट सरणी के अंदर पैरामीटरअरे को पास करना होगा जैसे कि इसे लागू करते समय। निम्नलिखित विधि है जो आपको काम करने की आवश्यकता है

private void ExecuteWithReflection(string methodName,object parameterObject = null)
{
    Assembly assembly = Assembly.LoadFile("Assembly.dll");
    Type typeInstance = assembly.GetType("TestAssembly.Main");

    if (typeInstance != null)
    {
        MethodInfo methodInfo = typeInstance.GetMethod(methodName);
        ParameterInfo[] parameterInfo = methodInfo.GetParameters();
        object classInstance = Activator.CreateInstance(typeInstance, null);

        if (parameterInfo.Length == 0)
        {
            // there is no parameter we can call with 'null'
            var result = methodInfo.Invoke(classInstance, null);
        }
        else
        {
            var result = methodInfo.Invoke(classInstance,new object[] { parameterObject } );
        }
    }
}

इस विधि से विधि को लागू करना आसान हो जाता है, इसे निम्नलिखित कहा जा सकता है

ExecuteWithReflection("Hello");
ExecuteWithReflection("Run","Vinod");
ExecuteWithReflection("TestNoParameters");
ExecuteWithReflection("Execute",new object[]{"Vinod","Srivastav"});

Answer 8

मैं प्रतिबिंब के माध्यम से भारित औसत का आह्वान कर रहा हूं। और एक से अधिक मापदंडों के साथ विधि का उपयोग किया था।

Class cls = Class.forName(propFile.getProperty(formulaTyp));// reading class name from file

Object weightedobj = cls.newInstance(); // invoke empty constructor

Class<?>[] paramTypes = { String.class, BigDecimal[].class, BigDecimal[].class }; // 3 parameter having first is method name and other two are values and their weight
Method printDogMethod = weightedobj.getClass().getMethod("applyFormula", paramTypes); // created the object 
return BigDecimal.valueOf((Double) printDogMethod.invoke(weightedobj, formulaTyp, decimalnumber, weight)); calling the method

Answer 9

string result = this.GetType().GetMethod("Print").Invoke(this, new object[]{"firstParam", 157, "third_Parammmm" } );

अगर यह बाहरी नहीं है। dll (इसके बजाय this.GetType(), आप उपयोग कर सकते हैं typeof(YourClass))।

ps इस उत्तर को पोस्ट कर रहे हैं क्योंकि कई आगंतुक इस उत्तर के लिए यहां आते हैं।