come lanciare implicitamente su una chiamata di metodo riflessa

Question

ho una classe Thing che è implicitamente calcinabile da un string. Quando chiamo un metodo con un Thing parametro direttamente il cast da string a Thing è fatto correttamente.

Tuttavia se uso riflessione di chiamare lo stesso metodo che genera l'eccezione

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

forse c'è una buona ragione per questo, ma non riesco a capirlo. Qualcuno ha un'idea di come farlo funzionare usando la riflessione?

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

Meta: Per favore, niente discussioni perché fusione implicita o di riflessione è male.

Answer 1

Trovato una risposta che utilizza un TypeConverter (come Saeed cita)
Sembra fare il lavoro.

TypeConverter For Implicit Conversion when using reflection

Answer 2

In questo caso specifico è possibile effettuare la conversione attraverso il tipo di matrice, cioè

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

ma questo è una sorta di "barare". In generale, non è possibile aspettarsi che lo Invoke consideri il proprio numero definito dall'utente implicit operator. Questa conversione deve essere dedotta in fase di compilazione.

Answer 3

Il trucco è quello di rendersi conto che il compilatore crea un metodo statico speciale chiamato op_Implicit per il vostro operatore di conversione implicita.

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