Il passaggio di un parametro dinamico genera RuntimeBinderException quando si chiama Method dall'interfaccia ereditata

Question

Si è verificato un problema di runtime dopo alcuni refactoring e si è bloccato fino alla seguente situazione.

Quando si passa una proprietà da un oggetto dinamico a un metodo su un'interfaccia ereditata da un'interfaccia padre, il raccoglitore di runtime non è in grado di trovare il metodo.

Ecco un test per dimostrare sia il fallimento e il successo (quando si chiama il metodo direttamente sul tipo di interfaccia madre)

using System.Dynamic; 
using Microsoft.CSharp.RuntimeBinder; 
using Microsoft.VisualStudio.TestTools.UnitTesting; 

namespace Test.Utility 
{ 
    public interface IEcho 
    { 
     string EchoString(string input); 
    } 

    public interface IInheritEcho : IEcho 
    { } 

    public class EchoClass : IInheritEcho 
    { 
     public string EchoString(string input) 
     { 
      return input; 
     } 
    } 

    [TestClass] 
    public class RuntimeBinderTest 
    { 
     [TestMethod] 
     public void RuntimeBinder_should_work_when_dynamic_parameters_are_passed_to_method_from_inherited_interface() 
     { 
      //Arrange 
      dynamic dynObject = new ExpandoObject(); 
      dynObject.Foo = "Bar"; 
      IInheritEcho echomore = new EchoClass(); 

      string echo = null; 
      string exceptionMessage = null; 

      //Act 
      try 
      { 
       echo = echomore.EchoString(dynObject.Foo); 
      } 
      catch (RuntimeBinderException e) 
      { 
       exceptionMessage = e.Message; 
      } 

      //Assert 
      Assert.AreEqual(echo, dynObject.Foo, false, exceptionMessage); 
     } 

     [TestMethod] 
     public void RuntimeBinder_should_work_when_dynamic_parameters_are_passed_to_method_from_noninherited_interface() 
     { 
      //Arrange 
      dynamic dynObject = new ExpandoObject(); 
      dynObject.Foo = "Bar"; 
      IEcho echomore = new EchoClass(); 

      string echo = null; 
      string exceptionMessage = null; 

      //Act 
      try 
      { 
       echo = echomore.EchoString(dynObject.Foo); 
      } 
      catch (RuntimeBinderException e) 
      { 
       exceptionMessage = e.Message; 
      } 

      //Assert 
      Assert.AreEqual(echo, dynObject.Foo, false, exceptionMessage); 
     } 
    } 
} 

Test # 1 non riesce: Assert.AreEqual riuscita. Previsto: < (null)>. Effettivo:. 'Test.Utility.IInheritEcho' non contiene una definizione per 'EchoString'

Test # 2 Riesce.

La mia domanda è se la mia ipotesi che il primo test debba passare è corretta o c'è una ragione fondamentale nel quadro che non lo è?

So che posso risolvere il problema colando i parametri quando li passo o li assegno alle variabili prima di passarle. Sono più curioso sul motivo per cui l'interfaccia ereditata sta causando il fallimento di RuntimeBinder. ..

Answer 1

Una buona domanda.

Sembrerebbe che stia prendendo il tipo dell'espressione in fase di compilazione, IInheritEcho, e non esegua ricerche approfondite sui membri delle interfacce ereditate quando si cerca il metodo da richiamare dinamicamente.

e, idealmente, il legante # runtime C per un dynamic espressione dovrebbe comportarsi allo stesso modo come il compilatore C# - quindi dovrebbe vedere che l'interfaccia IEcho viene ereditato da IInheritEcho e dovrebbe funzionare.

Siamo in grado di verificare l'ipotesi - vale a dire che è la tipizzazione statica - in questo modo nella prima prova:

echo = ((dynamic)echomore).EchoString(dynObject.Foo); 

Hey presto - il test viene superato.

Quindi il problema non è che il legante dinamica non riesce a trovare il metodo - è che quando l'istanza di cui membro viene richiamato in modo dinamico è staticamente tipizzato come interfaccia, interfacce ereditate non vengono consultati.

A mio parere questo comportamento non è corretto.

Si prega di Eric Lippert ... bello ...

Answer 2

Voi situazioni è un problema documentato sul Microsoft Connect