एक परावर्तित विधि कॉल पर अंतर्निहित रूप से कैसे डाला जाए

Question

मेरे पास कक्षा Thing है जो string से पूरी तरह से जाली योग्य है। जब मैं Thing पैरामीटर के साथ विधि को कॉल करता हूं तो सीधे string से Thing पर कास्ट सही ढंग से किया जाता है।

लेकिन अगर मैं प्रतिबिंब का उपयोग एक ही विधि का यह अपवाद

System.ArgumentException : Object of type 'System.String' cannot be 
converted to type 'Things.Program+Thing'. 

हो सकता है कि वहाँ इस के लिए एक अच्छा कारण है फेंकता कॉल करने के लिए, लेकिन मैं इसे समझ नहीं कर सकते हैं। क्या किसी को यह पता है कि प्रतिबिंब का उपयोग करके यह कैसे काम करना है?

namespace Things 
{ 
    class Program 
    { 
     public class Thing 
     { 
      public string Some; 

      public static implicit operator Thing(string s) 
      { 
       return new Thing {Some = s}; 
      } 
     } 

     public void showThing(Thing t) 
     { 
      Console.WriteLine("Some = " + t.Some); 
     } 

     public void Main() 
     { 
      showThing("foo"); 
      MethodInfo showThingReflected = GetType().GetMethod("showThing"); 
      showThingReflected.Invoke(this, new dynamic[] {"foo"}); 
     } 
    } 
} 

मेटा: कृपया, कोई चर्चा क्यों अंतर्निहित कास्टिंग या प्रतिबिंब बुरा है।

Answer 1

एक उत्तर मिला जो टाइपकॉन्टर (सईद उल्लेख के रूप में)
का उपयोग करता है जो नौकरी करने के लिए लगता है।

TypeConverter For Implicit Conversion when using reflection

Answer 2

इस विशिष्ट मामले में आप सरणी प्रकार के माध्यम से रूपांतरण कर सकते हैं, कि

showThingReflected.Invoke(this, new Thing[] {"foo"}); 

है, लेकिन है कि "धोखा दे" का एक प्रकार है। आम तौर पर, आप अपने उपयोगकर्ता द्वारा परिभाषित implicit operator पर विचार करने के लिए Invoke की अपेक्षा नहीं कर सकते हैं। यह रूपांतरण अनुमानित संकलन-समय होना चाहिए।

Answer 3

चाल को एहसास है कि संकलक एक विशेष स्थिर विधि अपने निहित रूपांतरण ऑपरेटर के लिए op_Implicit कहा जाता है बनाता है।

object arg = "foo"; 

// Program.showThing(Thing t) 
var showThingReflected = GetType().GetMethod("showThing"); 

// typeof(Thing) 
var paramType = showThingReflected.GetParameters() 
            .Single() 
            .ParameterType; 

// Thing.implicit operator Thing(string s) 
var converter = paramType.GetMethod("op_Implicit", new[] { arg.GetType() }); 

if (converter != null) 
    arg = converter.Invoke(null, new[] { arg }); // Converter exists: arg = (Thing)"foo"; 

// showThing(arg) 
showThingReflected.Invoke(this, new[] { arg });