Cómo realizar implícitamente una llamada a un método reflejado

Question

Tengo una clase Thing que se puede convertir implícitamente de string. Cuando llamo a un método con un parámetro Thing directamente, la conversión de string a Thing se realiza correctamente.

Sin embargo si uso reflexión para llamar al mismo método que produce la excepción

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

tal vez hay una buena razón para esto, pero no puedo entenderlo. ¿Alguien tiene una idea de cómo hacer que esto funcione usando la reflexión?

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: Por favor, no hay por qué las discusiones de fundición o de reflexión implícita es malo.

Answer 1

Encontré una respuesta que utiliza un TypeConverter (como menciona Saeed)
Parece que hace el trabajo.

TypeConverter For Implicit Conversion when using reflection

Answer 2

En este caso específico se puede hacer la conversión a través del tipo de matriz, es decir

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

pero eso es una especie de "trampa". En general, no puede esperar que el Invoke tenga en cuenta su implicit operator definido por el usuario. Esta conversión debe deducirse en tiempo de compilación.

Answer 3

El truco es darse cuenta de que el compilador crea un método estático especial llamado op_Implicit para su operador de conversión implícita.

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