conversión explícita del valor de retorno método dinámico dentro de un método no permite un método de extensión que se llamará

Question

El código siguiente muestra mi pregunta:

public class DynamicExample 
{ 
    public void DoSomething() 
    { 
     var x = new ExpandoObject(); 
     dynamic d = x; 
     d.GetString = (Func<string>)(() => "Some Value"); 

     d.GetString().SomeStringExtension(); // Doesn't work - expected 
     ((string)d.GetString()).SomeStringExtension(); // Works - expected 
     Build(d).SomeStringExtension(); // Doesn't work - unexpected? 
    } 

    private static string Build(dynamic d) 
    { 
     return (string)d.GetString(); 
    } 
} 

public static class StringExtensions 
{ 
    public static int SomeStringExtension(this string s) 
    { 
     return s.Length; 
    } 
} 

La pregunta es, ¿por qué hay una diferencia entre el compilador ¿Lanzando el tipo en línea a la llamada del método de extensión y moviendo ese lanzamiento en un método separado?

Answer 1

Build(d) sigue siendo una expresión dinámica - el tipo en tiempo de compilación del método es dynamic a pesar de que puede ver exactamente lo que está pasando. Eso significa que los métodos de extensión no funcionarán.

Básicamente el compilador sigue razonablemente sencillas reglas para determinar cuál es el tipo de una expresión es, y casi cualquier expresión que implique dynamic termina siendo considerada como una expresión dinámica. Las excepciones a esto son:

• d is SomeType (siempre considerado como bool)
• yesos, tanto directa como mediante as

Eso es por lo que yo puedo recordar, a pesar de que podría ser confundido ...

Ahora el idioma podría haber sido diseñado de tal manera que este caso sería estáticamente resuelva la llamada al Build como la única razonable; después de todo, es imposible que d sea de cualquier tipo de que cambiaría el método que se llama, pero especificar las reglas exactas para eso haría que las especificaciones del lenguaje (y el compilador) significativamente más complicado con relativamente poca ganancia.

Answer 2

Si pasa el mouse sobre Build(d) en VS2010, verá que toda la expresión se considera dinámica y se resolverá en tiempo de ejecución. Como tal, no se puede vincular al método de extensión (que de otro modo ocurriría en tiempo de compilación).

El motivo por el que toda la expresión es dynamic es que sin conocer el tipo de argumento en tiempo de compilación, resolución de sobrecarga no puede ser no se realiza, por lo que el tipo de devolución del método no puede ser tampoco se conoce.