Il C# 4 consentirà "casting dinamico"? In caso negativo, dovrebbe C# supportarlo?

Question

Non intendo il casting dinamico nel senso di trasmettere un'interfaccia inferiore o una classe base a una classe più derivata, cioè prendere una definizione di interfaccia che ho creato e quindi trasmettere dinamicamente a quell'interfaccia un oggetto diverso NON derivato da quella interfaccia ma supporta tutte le chiamate.

Per esempio,

interface IMyInterface 
{ 
    bool Visible 
    { 
     get; 
    } 
} 

TextBox myTextBox = new TextBox(); 
IMyInterface i = (dynamic<IMyInterface>)myTextBox; 

Ciò potrebbe essere realizzato al momento della compilazione per i tipi conosciuti, e runtime per le istanze dichiarate con dinamica. La definizione dell'interfaccia è nota, così come il tipo (in questo esempio) in modo che il compilatore possa determinare se l'oggetto supporta le chiamate definite dall'interfaccia ed eseguire un po 'di magia per noi per avere il cast.

La mia ipotesi è che questo non è supportato in C# 4 (non sono riuscito a trovare un riferimento ad esso), ma mi piacerebbe sapere con certezza. E se non lo è, mi piacerebbe discutere se dovrebbe essere incluso in una futura variante della lingua o meno, e le ragioni pro e contro. Per me, sembra una buona aggiunta per abilitare un maggiore polimorfismo nel codice senza dover creare tipi completamente nuovi per racchiudere i tipi di framework esistenti.

Aggiornamento
Per timore che qualcuno mi accusano di plagio, non ero a conoscenza di Jon Skeet having already proposed this. Comunque, è bello sapere che abbiamo pensato a una sintassi estremamente simile, il che suggerisce che potrebbe essere almeno intuitivo. Nel frattempo, "avere un'idea originale" rimane nella mia lista dei secchi per un altro giorno.

Answer 1

Penso che Jon Skeet abbia avuto una tale proposta (http://msmvps.com/blogs/jon_skeet/archive/2008/10/30/c-4-0-dynamic-lt-t-gt.aspx), ma finora non ho sentito che C# 4.0 ce l'avrà.

Answer 2

Penso che sia problematico. Stai introducendo l'accoppiamento tra due classi che non sono accoppiate.

Considerare il seguente codice.

public interface IFoo 
{ 
    int MethodA(); 
    int MethodB(); 
} 

public class Bar 
{ 
    int MethodA(); 
    int MethodB(); 
} 

public class SomeClass 
{ 
    int MethodFoo(IFoo someFoo); 
} 

dovrebbe essere legale?

int blah = someClass.MethodFoo((dynamic<IFoo>)bar); 

E sembra come dovrebbe essere legale, perché il compilatore dovrebbe essere in grado di digitare in modo dinamico bar come qualcosa che implementa IFoo.

Tuttavia, a questo punto si stanno combinando IFoo e Bar tramite una chiamata in una parte completamente separata del codice.

Se si modifica la barra perché non ha più bisogno di MethodB, improvvisamente someClass.MethodFood non funziona più, anche se Bar e IFoo non sono correlati.

Allo stesso modo, se si aggiunge MethodC() a IFoo, il codice si interromperà di nuovo, anche se IFoo e Bar sono apparentemente non correlati.

Il fatto è che, sebbene ciò sia utile in alcuni casi in cui vi sono delle somiglianze tra gli oggetti che non si controllano, esiste una ragione per cui le interfacce devono essere esplicitamente associate agli oggetti e il motivo è che il compilatore può garantire che l'oggetto lo implementa.

Answer 3

Non è necessario che C# supporti questo, in quanto può essere implementato in modo molto pulito come libreria.

Ho visto tre o quattro implementazioni separate (ho iniziato a scriverne una prima di trovarle). Ecco il trattamento più completo che ho visto:

http://bartdesmet.net/blogs/bart/archive/2008/11/10/introducing-the-c-ducktaper-bridging-the-dynamic-world-with-the-static-world.aspx

Probabilmente sarà ancora più facile da implementare una volta che il DLR è integrato nella fase di esecuzione.

Poiché la classe wrapper/forwarder per una determinata interfaccia può essere generata una volta e quindi memorizzata nella cache, e quindi un determinato oggetto di tipo sconosciuto può essere spostato una volta, c'è molto spazio per la memorizzazione nella cache dei siti di chiamata, ecc. la performance dovrebbe essere eccellente. Al contrario, penso che la parola chiave dynamic, che è una caratteristica del linguaggio e molto complessa, sia una digressione inutile e potenzialmente disastrosa, con un linguaggio che in precedenza aveva una filosofia di tipizzazione statica molto chiara, che ha dato una direzione ovvia per il miglioramento futuro. Dovrebbero essersi attenuti a questo e hanno reso l'inferenza di tipo funzionante sempre meglio fino a quando la digitazione è diventata più invisibile. Ci sono così tante aree in cui potrebbero evolvere la lingua, senza rompere i programmi esistenti, eppure non lo fanno, semplicemente a causa di limiti di risorse (ad esempio il motivo var non può essere utilizzato in più posti è perché dovrebbero riscrivere il compilatore e non hanno tempo).

Stanno ancora facendo cose buone in C# 4.0 (le caratteristiche della varianza) ma c'è molto altro che potrebbe essere fatto per rendere il sistema di tipi più intelligente, più automatico, più potente nel rilevare i problemi in fase di compilazione. Invece, stiamo essenzialmente ottenendo un espediente.

Answer 4

Il framework opensource Impromptu-Interface utilizza il C# 4 e il dlr.

using ImpromptuInterface; 

interface IMyInterface 
{ 
    bool Visible 
    { 
     get; 
    } 
} 

TextBox myTextBox = new TextBox(); 
IMyInterface i = myTextBox.ActLike<IMyInterface>(); 

Poiché utilizza il dlr, funzionerà anche con ExpandoObject e DynamicObject.